More Config Updates (#351)

Remove all mentions of the DB Wizard, explicit postgres start commands.

Author: kraftp

docs/python/integrating-dbos.md

@@ -8,11 +8,17 @@ This guide shows you how to add the open-source [DBOS Transact](https://github.c
 
 ### 1. Install DBOS
 `pip install` DBOS into your application.
-Then, create a DBOS configuration file (this file is optional but is used by tooling like the DBOS CLI and debugger).
 
 ```shell
 pip install dbos
-dbos init my-app --config
+```
+
+DBOS requires a Postgres database.
+If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string (later we'll pass that value into DBOS).
+Otherwise, you can start Postgres in a Docker container with this command:
+
+```shell
+dbos postgres start
 ```
 
 ### 2. Add the DBOS Initializer
@@ -36,11 +42,7 @@ DBOS.launch()
 ### 3. Start Your Application
 
 Try starting your application.
-When `DBOS.launch()` is called, it will attempt to connect to a Postgres database.
-If your project already uses Postgres, set the `DBOS_DATABASE_URL` environment variable to a connection string to your Postgres database.
-Otherwise, DBOS will automatically guide you through launching a new Postgres database (using Docker if available, else DBOS Cloud) and connecting to it.
-
-After you've connected to Postgres, your app should run normally, but log `Initializing DBOS` and `DBOS launched!` on startup.
+If everything is set up correctly, your app should run normally, but log `Initializing DBOS` and `DBOS launched!` on startup.
 Congratulations!  You've integrated DBOS into your application.
 
 

docs/python/programming-guide.md

@@ -35,10 +35,18 @@ cd dbos-starter
 </TabItem>
 </Tabs>
 
-Then, install DBOS and create a DBOS configuration file:
+Then, install DBOS:
+
 ```shell
 pip install dbos
-dbos init dbos-starter --config
+```
+
+DBOS requires a Postgres database.
+If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string (later we'll pass that value into DBOS).
+Otherwise, you can start Postgres in a Docker container with this command:
+
+```shell
+dbos postgres start
 ```
 
 ## 2. Workflows and Steps
@@ -82,10 +90,6 @@ If your program crashes or is interrupted, DBOS uses this saved state to recover
 Thus, DBOS makes your application **resilient to any failure**.
 
 Now, run this code with `python3 main.py`.
-When DBOS is launched, it attempts to connect to a Postgres database.
-If you already use Postgres, set the `DBOS_DATABASE_URL` environment variable to a connection string to your Postgres database.
-Otherwise, DBOS will automatically guide you through launching a new Postgres database (using Docker if available, else DBOS Cloud) and connecting to it.
-
 Your program should print output like:
 
 ```shell
@@ -327,20 +331,12 @@ This creates a `migrations/` directory in your application.
 Next, add the following code to `migrations/env.py` right before the `run_migrations_offline` function:
 
 ```python showLineNumbers title="migrations/env.py"
-from dbos import get_dbos_database_url
-import re
+import os
 from schema import metadata
 
 target_metadata = metadata
-
-# Programmatically set the sqlalchemy.url field from the DBOS config
-# Alembic requires the % in URL-escaped parameters be escaped to %%.
-escaped_conn_string = re.sub(
-    r"%(?=[0-9A-Fa-f]{2})",
-    "%%",
-    get_dbos_database_url(),
-)
-config.set_main_option("sqlalchemy.url", escaped_conn_string)
+conn_string = os.environ.get("DBOS_DATABASE_URL", "postgresql+psycopg://postgres:dbos@localhost:5432/dbos_starter")
+config.set_main_option("sqlalchemy.url", conn_string)
 ```
 
 This code imports your table schema into Alembic and tells it to load its database connection parameters from your DBOS configuration file.

docs/python/reference/dbos-class.md

@@ -38,11 +38,6 @@ Should be called after all decorators run.
 **You should not call a DBOS function until after DBOS is launched.**
 If a FastAPI app is passed into the `DBOS` constructor, `launch` is called automatically during FastAPI setup.
 
-`DBOS.launch()` connects your app to a Postgres database.
-It looks for database connection parameters in your [`dbos-config.yaml`](./configuration.md) and `.dbos/db_connection` files.
-If those parameters are set to default values and no database is found, it prompts you to launch a local Postgres database using Docker.
-If Docker is not found, it prompts you to connect to a database hosted on DBOS Cloud.
-
 **Example:**
 ```python
 from dbos import DBOS
@@ -108,33 +103,3 @@ Destroy the DBOS [system database](../../explanations/how-workflows-work.md), re
 Useful when testing a DBOS application to reset the internal state of DBOS between tests.
 For example, see its use in the [testing tutorial](../tutorials/testing.md).
 **This is a destructive operation and should only be used in a test environment.**
-
-## Configuration Management
-
-### load_config
-
-```python
-load_config(
-    config_file_path: str = "dbos-config.yaml",
-    use_db_wizard: bool = True
-) -> ConfigFile:
-```
-
-Load and parse a DBOS configuration file into a `ConfigFile` object.
-
-**Parameters:**
-- `config_file_path`: The path to the DBOS configuration file to parse.
-- `use_db_wizard`: If the configuration file specifies default database connection parameters and there is no Postgres database there, whether to prompt the user to connect to a different database.
-
-### get_dbos_database_url
-
-```python
-get_dbos_database_url(
-    config_file_path: str = "dbos-config.yaml"
-) -> str
-```
-
-Parse database connection information from a DBOS configuration file into a Postgres database connection string.
-
-**Parameters:**
-- `config_file_path`: The path to the DBOS configuration file to parse.

docs/quickstart.md

@@ -17,7 +17,7 @@ This guide shows you how to install and run it on your computer.
 <article className="col col--6">
 
 #### 1. Create a Virtual Environment
-In a clean directory, create a Python virtual environment.
+Create and activate a Python virtual environment in a directory.
 DBOS requires Python 3.9 or later.
 
 </article>
@@ -27,25 +27,22 @@ DBOS requires Python 3.9 or later.
 <Tabs groupId="operating-systems" className="small-tabs">
 <TabItem value="maclinux" label="macOS or Linux">
 ```shell
-mkdir my-app
-cd my-app
-python3 -m venv .venv
+python3 -m venv dbos-app-starter/.venv
+cd dbos-app-starter
 source .venv/bin/activate
 ```
 </TabItem>
 <TabItem value="win-ps" label="Windows (PowerShell)">
 ```shell
-mkdir my-app
-cd my-app
-python3 -m venv .venv
+python3 -m venv dbos-app-starter/.venv
+cd dbos-app-starter
 .venv\Scripts\activate.ps1
 ```
 </TabItem>
 <TabItem value="win-cmd" label="Windows (cmd)">
 ```shell
-mkdir my-app
-cd my-app
-python3 -m venv .venv
+python3 -m venv dbos-app-starter/.venv
+cd dbos-app-starter
 .venv\Scripts\activate.bat
 ```
 </TabItem>
@@ -58,7 +55,7 @@ python3 -m venv .venv
 <article className="col col--6">
 
 #### 2. Install and Initialize DBOS
-Install DBOS with `pip install dbos`, then initialize `dbos-app-starter`, an example application built with DBOS and FastAPI.
+Install DBOS with `pip install dbos`, then initialize an example application.
 
 </article>
 
@@ -78,13 +75,14 @@ dbos init --template dbos-app-starter
 <section className="row list">
 
 <article className="col col--6">
-DBOS needs a Postgres database to connect to. If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string. Otherwise, you can use the Docker script we provide to start it like so:
+DBOS requires a Postgres database.
+If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string.
+Otherwise, you can start Postgres in a Docker container with this command:
 </article>
 
 <article className="col col--6">
 ```bash
-export PGPASSWORD=dbos
-python3 start_postgres_docker.py
+dbos postgres start
 ```
 </article>
 
@@ -94,7 +92,7 @@ Now, start your app!
 
 <article className="col col--6">
 ```bash
-fastapi run app/main.py
+python3 app/main.py
 ```
 </article>
 
@@ -104,7 +102,7 @@ To see that your app is working, visit this URL in your browser: http://localhos
 This app lets you test the reliability of DBOS for yourself.
 Launch a durable workflow and watch it execute its three steps.
 At any point, crash the app.
-Then, restart it with `fastapi run app/main.py` and watch it seamlessly recover from where it left off.
+Then, restart it with `python3 app/main.py` and watch it seamlessly recover from where it left off.
 
 
 Congratulations, you've run your first durable workflow with DBOS!
@@ -171,9 +169,20 @@ npm run build
 
 <section className="row list">
 
+<article className="col col--6">
+DBOS requires a Postgres database.
+If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string.
+Otherwise, you can start Postgres in a Docker container with this command:
+</article>
+
+<article className="col col--6">
+```bash
+npx dbos postgres start
+```
+</article>
+
 <article className="col col--6">
 Now, start your app!
-DBOS will automatically help you launch and connect to a new Postgres database (using Docker if available, else DBOS Cloud).
 
 </article>
 

docs/typescript/examples/task-scheduler.md

@@ -33,7 +33,13 @@ After a bit of launch activity, you will be presented with:
 If you [started out in DBOS Cloud](#running-dbos-task-scheduler-in-dbos-cloud), you can download your code to your development environment.  Or, you can [clone the code from the git repository](https://github.com/dbos-inc/dbos-demo-apps) and change to the `typescript/nextjs-calendar` directory.
 
 ### Setting Up A Database
-DBOS requires a Postgres database.  If your local environment is set up with database connection settings, these will be used.  If not, the "database wizard" will help establish a connection.
+DBOS requires a Postgres database.
+If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string.
+Otherwise, you can start Postgres in a Docker container with this command:
+
+```shell
+npx dbos postgres start
+```
 
 
 ### Running In Development

docs/typescript/integrating-dbos.md

@@ -18,7 +18,7 @@ Also check out the integration guides for popular TypeScript frameworks:
 `npm install` DBOS into your application. Note that DBOS requires Node.js 20 or later.
 
 ```shell
-npm install @dbos-inc/dbos-sdk
+npm install @dbos-inc/dbos-sdk@latest
 ```
 
 Then, enable TypeScript decorators in your `tsconfig.json` file:
@@ -29,6 +29,14 @@ Then, enable TypeScript decorators in your `tsconfig.json` file:
   }
 ```
 
+DBOS requires a Postgres database.
+If you already have Postgres, you can set the `DBOS_DATABASE_URL` environment variable to your connection string (later we'll pass that value into DBOS).
+Otherwise, you can start Postgres in a Docker container with this command:
+
+```shell
+npx dbos postgres start
+```
+
 
 #### 2. Initialize DBOS in Your App
 
@@ -48,11 +56,7 @@ await DBOS.launch();
 #### 3. Start Your Application
 
 Try starting your application.
-When `DBOS.launch()` is called, it will attempt to connect to a Postgres database.
-If your project already uses Postgres, set the `DBOS_DATABASE_URL` environment variable to a connection string to your Postgres database.
-Otherwise, DBOS will automatically guide you through launching a new Postgres database (using Docker if available, else DBOS Cloud) and connecting to it.
-
-After you've connected to Postgres, your app should run normally, but log `DBOS launched` on startup.
+If everything is set up correctly, your app should run normally, but log `DBOS launched!` on startup.
 Congratulations!  You've integrated DBOS into your application.
 
 #### 4. Start Building With DBOS