dbos 1.15.0a1__py3-none-any.whl → 1.15.0a3__py3-none-any.whl

dbos/_app_db.py

@@ -241,6 +241,7 @@ class ApplicationDatabase(ABC):
     def create(
         database_url: str,
         engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
         debug_mode: bool = False,
     ) -> "ApplicationDatabase":
         """Factory method to create the appropriate ApplicationDatabase implementation based on URL."""
@@ -256,12 +257,32 @@ class ApplicationDatabase(ABC):
                 database_url=database_url,
                 engine_kwargs=engine_kwargs,
                 debug_mode=debug_mode,
+                schema=schema,
             )
 
 
 class PostgresApplicationDatabase(ApplicationDatabase):
     """PostgreSQL-specific implementation of ApplicationDatabase."""
 
+    def __init__(
+        self,
+        *,
+        database_url: str,
+        engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
+        debug_mode: bool = False,
+    ):
+        super().__init__(
+            database_url=database_url,
+            engine_kwargs=engine_kwargs,
+            debug_mode=debug_mode,
+        )
+        if schema is None:
+            self.schema = "dbos"
+        else:
+            self.schema = schema
+        ApplicationSchema.transaction_outputs.schema = schema
+
     def _create_engine(
         self, database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
@@ -271,9 +292,6 @@ class PostgresApplicationDatabase(ApplicationDatabase):
         if engine_kwargs is None:
             engine_kwargs = {}
 
-        # TODO: Make the schema dynamic so this isn't needed
-        ApplicationSchema.transaction_outputs.schema = "dbos"
-
         return sa.create_engine(
             app_db_url,
             **engine_kwargs,
@@ -307,24 +325,18 @@ class PostgresApplicationDatabase(ApplicationDatabase):
                 sa.text(
                     "SELECT 1 FROM information_schema.schemata WHERE schema_name = :schema_name"
                 ),
-                parameters={"schema_name": ApplicationSchema.schema},
+                parameters={"schema_name": self.schema},
             ).scalar()
 
             if not schema_exists:
-                schema_creation_query = sa.text(
-                    f"CREATE SCHEMA {ApplicationSchema.schema}"
-                )
+                schema_creation_query = sa.text(f'CREATE SCHEMA "{self.schema}"')
                 conn.execute(schema_creation_query)
 
         inspector = inspect(self.engine)
-        if not inspector.has_table(
-            "transaction_outputs", schema=ApplicationSchema.schema
-        ):
+        if not inspector.has_table("transaction_outputs", schema=self.schema):
             ApplicationSchema.metadata_obj.create_all(self.engine)
         else:
-            columns = inspector.get_columns(
-                "transaction_outputs", schema=ApplicationSchema.schema
-            )
+            columns = inspector.get_columns("transaction_outputs", schema=self.schema)
             column_names = [col["name"] for col in columns]
 
             if "function_name" not in column_names:
@@ -333,7 +345,7 @@ class PostgresApplicationDatabase(ApplicationDatabase):
                     conn.execute(
                         text(
                             f"""
-                        ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
+                        ALTER TABLE \"{self.schema}\".transaction_outputs
                         ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
                         """
                         )

dbos/_client.py

@@ -22,11 +22,7 @@ from dbos._sys_db import SystemDatabase
 if TYPE_CHECKING:
     from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
 
-from dbos._dbos_config import (
-    get_application_database_url,
-    get_system_database_url,
-    is_valid_database_url,
-)
+from dbos._dbos_config import get_system_database_url, is_valid_database_url
 from dbos._error import DBOSException, DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
@@ -118,21 +114,20 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
 
 class DBOSClient:
+
+    _app_db: ApplicationDatabase | None = None
+
     def __init__(
         self,
         database_url: Optional[str] = None,  # DEPRECATED
         *,
         system_database_url: Optional[str] = None,
         application_database_url: Optional[str] = None,
+        dbos_system_schema: Optional[str] = "dbos",
         system_database: Optional[str] = None,  # DEPRECATED
     ):
-        application_database_url = get_application_database_url(
-            {
-                "system_database_url": system_database_url,
-                "database_url": (
-                    database_url if database_url else application_database_url
-                ),
-            }
+        application_database_url = (
+            database_url if database_url else application_database_url
         )
         system_database_url = get_system_database_url(
             {
@@ -142,7 +137,8 @@ class DBOSClient:
             }
         )
         assert is_valid_database_url(system_database_url)
-        assert is_valid_database_url(application_database_url)
+        if application_database_url:
+            assert is_valid_database_url(application_database_url)
         # We only create database connections but do not run migrations
         self._sys_db = SystemDatabase.create(
             system_database_url=system_database_url,
@@ -151,16 +147,19 @@ class DBOSClient:
                 "max_overflow": 0,
                 "pool_size": 2,
             },
+            schema=dbos_system_schema,
         )
         self._sys_db.check_connection()
-        self._app_db = ApplicationDatabase.create(
-            database_url=application_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
-        )
+        if application_database_url:
+            self._app_db = ApplicationDatabase.create(
+                database_url=application_database_url,
+                engine_kwargs={
+                    "pool_timeout": 30,
+                    "max_overflow": 0,
+                    "pool_size": 2,
+                },
+                schema=dbos_system_schema,
+            )
 
     def destroy(self) -> None:
         self._sys_db.destroy()

dbos/_core.py

@@ -896,7 +896,9 @@ def decorate_transaction(
                 raise DBOSWorkflowCancelledError(
                     f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {transaction_name}."
                 )
-
+            assert (
+                dbos._app_db
+            ), "Transactions can only be used if DBOS is configured with an application_database_url"
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
                     "name": transaction_name,

dbos/_dbos.py

@@ -409,13 +409,8 @@ class DBOS:
         return rv
 
     @property
-    def _app_db(self) -> ApplicationDatabase:
-        if self._app_db_field is None:
-            raise DBOSException(
-                "Application database accessed before DBOS was launched"
-            )
-        rv: ApplicationDatabase = self._app_db_field
-        return rv
+    def _app_db(self) -> ApplicationDatabase | None:
+        return self._app_db_field
 
     @property
     def _admin_server(self) -> AdminServer:
@@ -448,26 +443,31 @@ class DBOS:
             dbos_logger.info(f"Application version: {GlobalParams.app_version}")
             self._executor_field = ThreadPoolExecutor(max_workers=sys.maxsize)
             self._background_event_loop.start()
-            assert self._config["database_url"] is not None
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
+            # Get the schema configuration, use "dbos" as default
+            schema = self._config.get("dbos_system_schema", "dbos")
             self._sys_db_field = SystemDatabase.create(
                 system_database_url=get_system_database_url(self._config),
                 engine_kwargs=self._config["database"]["sys_db_engine_kwargs"],
                 debug_mode=debug_mode,
+                schema=schema,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
-            self._app_db_field = ApplicationDatabase.create(
-                database_url=self._config["database_url"],
-                engine_kwargs=self._config["database"]["db_engine_kwargs"],
-                debug_mode=debug_mode,
-            )
+            if self._config["database_url"]:
+                self._app_db_field = ApplicationDatabase.create(
+                    database_url=self._config["database_url"],
+                    engine_kwargs=self._config["database"]["db_engine_kwargs"],
+                    debug_mode=debug_mode,
+                    schema=schema,
+                )
 
             if debug_mode:
                 return
 
             # Run migrations for the system and application databases
             self._sys_db.run_migrations()
-            self._app_db.run_migrations()
+            if self._app_db:
+                self._app_db.run_migrations()
 
             admin_port = self._config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:

dbos/_dbos_config.py

@@ -1,4 +1,3 @@
-import json
 import os
 import re
 from importlib import resources
@@ -34,6 +33,7 @@ class DBOSConfig(TypedDict, total=False):
         otlp_attributes (dict[str, str]): A set of custom attributes to apply OTLP-exported logs and traces
         application_version (str): Application version
         executor_id (str): Executor ID, used to identify the application instance in distributed environments
+        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
         enable_otlp (bool): If True, enable built-in DBOS OTLP tracing and logging.
     """
 
@@ -52,6 +52,7 @@ class DBOSConfig(TypedDict, total=False):
     otlp_attributes: Optional[dict[str, str]]
     application_version: Optional[str]
     executor_id: Optional[str]
+    dbos_system_schema: Optional[str]
     enable_otlp: Optional[bool]
 
 
@@ -70,6 +71,7 @@ class DatabaseConfig(TypedDict, total=False):
         sys_db_pool_size (int): System database pool size
         db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs
         migrate (List[str]): Migration commands to run on startup
+        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
     """
 
     sys_db_name: Optional[str]
@@ -113,6 +115,7 @@ class ConfigFile(TypedDict, total=False):
         system_database_url (str): System database URL
         telemetry (TelemetryConfig): Configuration for tracing / logging
         env (Dict[str,str]): Environment variables
+        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
 
     """
 
@@ -123,6 +126,7 @@ class ConfigFile(TypedDict, total=False):
     system_database_url: Optional[str]
     telemetry: Optional[TelemetryConfig]
     env: Dict[str, str]
+    dbos_system_schema: Optional[str]
 
 
 def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
@@ -153,6 +157,9 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
     if "system_database_url" in config:
         translated_config["system_database_url"] = config.get("system_database_url")
 
+    if "dbos_system_schema" in config:
+        translated_config["dbos_system_schema"] = config.get("dbos_system_schema")
+
     # Runtime config
     translated_config["runtimeConfig"] = {"run_admin_server": True}
     if "admin_port" in config:
@@ -408,22 +415,20 @@ def process_config(
                 url = url.set(database=f"{url.database}{SystemSchema.sysdb_suffix}")
             data["system_database_url"] = url.render_as_string(hide_password=False)
 
-    # If a system database URL is provided but not an application database URL, set the
-    # application database URL to the system database URL.
+    # If a system database URL is provided but not an application database URL,
+    # do not create an application database.
     if data.get("system_database_url") and not data.get("database_url"):
         assert data["system_database_url"]
-        data["database_url"] = data["system_database_url"]
+        data["database_url"] = None
 
-    # If neither URL is provided, use a default SQLite database URL.
+    # If neither URL is provided, use a default SQLite system database URL.
     if not data.get("database_url") and not data.get("system_database_url"):
         _app_db_name = _app_name_to_db_name(data["name"])
-        data["system_database_url"] = data["database_url"] = (
-            f"sqlite:///{_app_db_name}.sqlite"
-        )
+        data["system_database_url"] = f"sqlite:///{_app_db_name}.sqlite"
+        data["database_url"] = None
 
     configure_db_engine_parameters(data["database"], connect_timeout=connect_timeout)
 
-    assert data["database_url"] is not None
     assert data["system_database_url"] is not None
     # Pretty-print connection information, respecting log level
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
@@ -431,7 +436,12 @@ def process_config(
             hide_password=True
         )
         print(f"DBOS system database URL: {printable_sys_db_url}")
-        if data["database_url"].startswith("sqlite"):
+        if data["database_url"]:
+            printable_app_db_url = make_url(data["database_url"]).render_as_string(
+                hide_password=True
+            )
+            print(f"DBOS application database URL: {printable_app_db_url}")
+        if data["system_database_url"].startswith("sqlite"):
             print(
                 f"Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use."
             )
@@ -543,6 +553,8 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
             "DBOS_SYSTEM_DATABASE_URL environment variable is not set. This is required to connect to the database."
         )
     provided_config["system_database_url"] = system_db_url
+    # Always use the "dbos" schema when deploying to DBOS Cloud
+    provided_config["dbos_system_schema"] = "dbos"
 
     # Telemetry config
     if "telemetry" not in provided_config or provided_config["telemetry"] is None:
@@ -615,12 +627,11 @@ def get_system_database_url(config: ConfigFile) -> str:
         )
 
 
-def get_application_database_url(config: ConfigFile) -> str:
+def get_application_database_url(config: ConfigFile) -> str | None:
     # For backwards compatibility, the application database URL is "database_url"
     if config.get("database_url"):
         assert config["database_url"]
         return config["database_url"]
     else:
-        # If the application database URL is not specified, set it to the system database URL
-        assert config["system_database_url"]
-        return config["system_database_url"]
+        # If the application database URL is not specified, return None
+        return None

dbos/_migration.py

@@ -5,7 +5,7 @@ import sqlalchemy as sa
 from ._logger import dbos_logger
 
 
-def ensure_dbos_schema(engine: sa.Engine) -> None:
+def ensure_dbos_schema(engine: sa.Engine, schema: str) -> None:
     """
     True if using DBOS migrations (DBOS schema and migrations table already exist or were created)
     False if using Alembic migrations (DBOS schema exists, but dbos_migrations table doesn't)
@@ -14,41 +14,46 @@ def ensure_dbos_schema(engine: sa.Engine) -> None:
         # Check if dbos schema exists
         schema_result = conn.execute(
             sa.text(
-                "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'dbos'"
-            )
+                "SELECT schema_name FROM information_schema.schemata WHERE schema_name = :schema"
+            ),
+            {"schema": schema},
         )
         schema_exists = schema_result.fetchone() is not None
 
         # Create schema if it doesn't exist
         if not schema_exists:
-            conn.execute(sa.text("CREATE SCHEMA dbos"))
+            conn.execute(sa.text(f'CREATE SCHEMA "{schema}"'))
 
         # Check if dbos_migrations table exists
         table_result = conn.execute(
             sa.text(
-                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'dbos' AND table_name = 'dbos_migrations'"
-            )
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = :schema AND table_name = 'dbos_migrations'"
+            ),
+            {"schema": schema},
         )
         table_exists = table_result.fetchone() is not None
 
         if not table_exists:
             conn.execute(
                 sa.text(
-                    "CREATE TABLE dbos.dbos_migrations (version BIGINT NOT NULL PRIMARY KEY)"
+                    f'CREATE TABLE "{schema}".dbos_migrations (version BIGINT NOT NULL PRIMARY KEY)'
                 )
             )
 
 
-def run_dbos_migrations(engine: sa.Engine) -> None:
+def run_dbos_migrations(engine: sa.Engine, schema: str) -> None:
     """Run DBOS-managed migrations by executing each SQL command in dbos_migrations."""
     with engine.begin() as conn:
         # Get current migration version
-        result = conn.execute(sa.text("SELECT version FROM dbos.dbos_migrations"))
+        result = conn.execute(
+            sa.text(f'SELECT version FROM "{schema}".dbos_migrations')
+        )
         current_version = result.fetchone()
         last_applied = current_version[0] if current_version else 0
 
         # Apply migrations starting from the next version
-        for i, migration_sql in enumerate(dbos_migrations, 1):
+        migrations = get_dbos_migrations(schema)
+        for i, migration_sql in enumerate(migrations, 1):
             if i <= last_applied:
                 continue
 
@@ -60,23 +65,26 @@ def run_dbos_migrations(engine: sa.Engine) -> None:
             if last_applied == 0:
                 conn.execute(
                     sa.text(
-                        "INSERT INTO dbos.dbos_migrations (version) VALUES (:version)"
+                        f'INSERT INTO "{schema}".dbos_migrations (version) VALUES (:version)'
                     ),
                     {"version": i},
                 )
             else:
                 conn.execute(
-                    sa.text("UPDATE dbos.dbos_migrations SET version = :version"),
+                    sa.text(
+                        f'UPDATE "{schema}".dbos_migrations SET version = :version'
+                    ),
                     {"version": i},
                 )
             last_applied = i
 
 
-dbos_migration_one = """
+def get_dbos_migration_one(schema: str) -> str:
+    return f"""
 -- Enable uuid extension for generating UUIDs
 CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
 
-CREATE TABLE dbos.workflow_status (
+CREATE TABLE \"{schema}\".workflow_status (
     workflow_uuid TEXT PRIMARY KEY,
     status TEXT,
     name TEXT,
@@ -103,15 +111,15 @@ CREATE TABLE dbos.workflow_status (
     priority INTEGER NOT NULL DEFAULT 0
 );
 
-CREATE INDEX workflow_status_created_at_index ON dbos.workflow_status (created_at);
-CREATE INDEX workflow_status_executor_id_index ON dbos.workflow_status (executor_id);
-CREATE INDEX workflow_status_status_index ON dbos.workflow_status (status);
+CREATE INDEX workflow_status_created_at_index ON \"{schema}\".workflow_status (created_at);
+CREATE INDEX workflow_status_executor_id_index ON \"{schema}\".workflow_status (executor_id);
+CREATE INDEX workflow_status_status_index ON \"{schema}\".workflow_status (status);
 
-ALTER TABLE dbos.workflow_status 
+ALTER TABLE \"{schema}\".workflow_status 
 ADD CONSTRAINT uq_workflow_status_queue_name_dedup_id 
 UNIQUE (queue_name, deduplication_id);
 
-CREATE TABLE dbos.operation_outputs (
+CREATE TABLE \"{schema}\".operation_outputs (
     workflow_uuid TEXT NOT NULL,
     function_id INTEGER NOT NULL,
     function_name TEXT NOT NULL DEFAULT '',
@@ -119,23 +127,23 @@ CREATE TABLE dbos.operation_outputs (
     error TEXT,
     child_workflow_id TEXT,
     PRIMARY KEY (workflow_uuid, function_id),
-    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
 
-CREATE TABLE dbos.notifications (
+CREATE TABLE \"{schema}\".notifications (
     destination_uuid TEXT NOT NULL,
     topic TEXT,
     message TEXT NOT NULL,
     created_at_epoch_ms BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
     message_uuid TEXT NOT NULL DEFAULT gen_random_uuid(), -- Built-in function
-    FOREIGN KEY (destination_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (destination_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
-CREATE INDEX idx_workflow_topic ON dbos.notifications (destination_uuid, topic);
+CREATE INDEX idx_workflow_topic ON \"{schema}\".notifications (destination_uuid, topic);
 
 -- Create notification function
-CREATE OR REPLACE FUNCTION dbos.notifications_function() RETURNS TRIGGER AS $$
+CREATE OR REPLACE FUNCTION \"{schema}\".notifications_function() RETURNS TRIGGER AS $$
 DECLARE
     payload text := NEW.destination_uuid || '::' || NEW.topic;
 BEGIN
@@ -146,20 +154,20 @@ $$ LANGUAGE plpgsql;
 
 -- Create notification trigger
 CREATE TRIGGER dbos_notifications_trigger
-AFTER INSERT ON dbos.notifications
-FOR EACH ROW EXECUTE FUNCTION dbos.notifications_function();
+AFTER INSERT ON \"{schema}\".notifications
+FOR EACH ROW EXECUTE FUNCTION \"{schema}\".notifications_function();
 
-CREATE TABLE dbos.workflow_events (
+CREATE TABLE \"{schema}\".workflow_events (
     workflow_uuid TEXT NOT NULL,
     key TEXT NOT NULL,
     value TEXT NOT NULL,
     PRIMARY KEY (workflow_uuid, key),
-    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
 
 -- Create events function
-CREATE OR REPLACE FUNCTION dbos.workflow_events_function() RETURNS TRIGGER AS $$
+CREATE OR REPLACE FUNCTION \"{schema}\".workflow_events_function() RETURNS TRIGGER AS $$
 DECLARE
     payload text := NEW.workflow_uuid || '::' || NEW.key;
 BEGIN
@@ -170,20 +178,20 @@ $$ LANGUAGE plpgsql;
 
 -- Create events trigger
 CREATE TRIGGER dbos_workflow_events_trigger
-AFTER INSERT ON dbos.workflow_events
-FOR EACH ROW EXECUTE FUNCTION dbos.workflow_events_function();
+AFTER INSERT ON \"{schema}\".workflow_events
+FOR EACH ROW EXECUTE FUNCTION \"{schema}\".workflow_events_function();
 
-CREATE TABLE dbos.streams (
+CREATE TABLE \"{schema}\".streams (
     workflow_uuid TEXT NOT NULL,
     key TEXT NOT NULL,
     value TEXT NOT NULL,
     "offset" INTEGER NOT NULL,
     PRIMARY KEY (workflow_uuid, key, "offset"),
-    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
 
-CREATE TABLE dbos.event_dispatch_kv (
+CREATE TABLE \"{schema}\".event_dispatch_kv (
     service_name TEXT NOT NULL,
     workflow_fn_name TEXT NOT NULL,
     key TEXT NOT NULL,
@@ -195,6 +203,10 @@ CREATE TABLE dbos.event_dispatch_kv (
 """
 
 
+def get_dbos_migrations(schema: str) -> list[str]:
+    return [get_dbos_migration_one(schema)]
+
+
 def get_sqlite_timestamp_expr() -> str:
     """Get SQLite timestamp expression with millisecond precision for Python >= 3.12."""
     if sys.version_info >= (3, 12):
@@ -281,5 +293,4 @@ CREATE TABLE streams (
 );
 """
 
-dbos_migrations = [dbos_migration_one]
 sqlite_migrations = [sqlite_migration_one]

dbos/_schemas/system_database.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from sqlalchemy import (
     BigInteger,
     Column,
@@ -19,6 +21,21 @@ class SystemSchema:
     metadata_obj = MetaData(schema="dbos")
     sysdb_suffix = "_dbos_sys"
 
+    @classmethod
+    def set_schema(cls, schema_name: Optional[str]) -> None:
+        """
+        Set the schema for all DBOS system tables.
+
+        Args:
+            schema_name: The name of the schema to use for system tables
+        """
+        cls.metadata_obj.schema = schema_name
+        cls.workflow_status.schema = schema_name
+        cls.operation_outputs.schema = schema_name
+        cls.notifications.schema = schema_name
+        cls.workflow_events.schema = schema_name
+        cls.streams.schema = schema_name
+
     workflow_status = Table(
         "workflow_status",
         metadata_obj,

dbos/_sys_db.py

@@ -1443,6 +1443,7 @@ class SystemDatabase(ABC):
     def create(
         system_database_url: str,
         engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
         debug_mode: bool = False,
     ) -> "SystemDatabase":
         """Factory method to create the appropriate SystemDatabase implementation based on URL."""
@@ -1461,6 +1462,7 @@ class SystemDatabase(ABC):
                 system_database_url=system_database_url,
                 engine_kwargs=engine_kwargs,
                 debug_mode=debug_mode,
+                schema=schema,
             )
 
     @db_retry()

dbos/_sys_db_postgres.py

@@ -20,6 +20,7 @@ class PostgresSystemDatabase(SystemDatabase):
         *,
         system_database_url: str,
         engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
         debug_mode: bool = False,
     ):
         super().__init__(
@@ -27,17 +28,16 @@ class PostgresSystemDatabase(SystemDatabase):
             engine_kwargs=engine_kwargs,
             debug_mode=debug_mode,
         )
+        if schema is None:
+            self.schema = "dbos"
+        else:
+            self.schema = schema
+        SystemSchema.set_schema(self.schema)
         self.notification_conn: Optional[psycopg.connection.Connection] = None
 
     def _create_engine(
         self, system_database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
-        # TODO: Make the schema dynamic so this isn't needed
-        SystemSchema.workflow_status.schema = "dbos"
-        SystemSchema.operation_outputs.schema = "dbos"
-        SystemSchema.notifications.schema = "dbos"
-        SystemSchema.workflow_events.schema = "dbos"
-        SystemSchema.streams.schema = "dbos"
         url = sa.make_url(system_database_url).set(drivername="postgresql+psycopg")
         return sa.create_engine(url, **engine_kwargs)
 
@@ -62,8 +62,8 @@ class PostgresSystemDatabase(SystemDatabase):
                 conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
         engine.dispose()
 
-        ensure_dbos_schema(self.engine)
-        run_dbos_migrations(self.engine)
+        ensure_dbos_schema(self.engine, self.schema)
+        run_dbos_migrations(self.engine, self.schema)
 
     def _cleanup_connections(self) -> None:
         """Clean up PostgreSQL-specific connections."""

dbos/_sys_db_sqlite.py

@@ -19,12 +19,7 @@ class SQLiteSystemDatabase(SystemDatabase):
         self, system_database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
         """Create a SQLite engine."""
-        # TODO: Make the schema dynamic so this isn't needed
-        SystemSchema.workflow_status.schema = None
-        SystemSchema.operation_outputs.schema = None
-        SystemSchema.notifications.schema = None
-        SystemSchema.workflow_events.schema = None
-        SystemSchema.streams.schema = None
+        SystemSchema.set_schema(None)
         return sa.create_engine(system_database_url)
 
     def run_migrations(self) -> None:

dbos/_workflow_commands.py

@@ -98,10 +98,10 @@ def get_workflow(sys_db: SystemDatabase, workflow_id: str) -> Optional[WorkflowS
 
 
 def list_workflow_steps(
-    sys_db: SystemDatabase, app_db: ApplicationDatabase, workflow_id: str
+    sys_db: SystemDatabase, app_db: Optional[ApplicationDatabase], workflow_id: str
 ) -> List[StepInfo]:
     steps = sys_db.get_workflow_steps(workflow_id)
-    transactions = app_db.get_transactions(workflow_id)
+    transactions = app_db.get_transactions(workflow_id) if app_db else []
     merged_steps = steps + transactions
     merged_steps.sort(key=lambda step: step["function_id"])
     return merged_steps
@@ -109,7 +109,7 @@ def list_workflow_steps(
 
 def fork_workflow(
     sys_db: SystemDatabase,
-    app_db: ApplicationDatabase,
+    app_db: Optional[ApplicationDatabase],
     workflow_id: str,
     start_step: int,
     *,
@@ -122,7 +122,8 @@ def fork_workflow(
         ctx.id_assigned_for_next_workflow = ""
     else:
         forked_workflow_id = str(uuid.uuid4())
-    app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
+    if app_db:
+        app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
     sys_db.fork_workflow(
         workflow_id,
         forked_workflow_id,
@@ -145,7 +146,10 @@ def garbage_collect(
     )
     if result is not None:
         cutoff_epoch_timestamp_ms, pending_workflow_ids = result
-        dbos._app_db.garbage_collect(cutoff_epoch_timestamp_ms, pending_workflow_ids)
+        if dbos._app_db:
+            dbos._app_db.garbage_collect(
+                cutoff_epoch_timestamp_ms, pending_workflow_ids
+            )
 
 
 def global_timeout(dbos: "DBOS", cutoff_epoch_timestamp_ms: int) -> None:

dbos/cli/cli.py

@@ -38,7 +38,7 @@ class DefaultEncoder(json.JSONEncoder):
 
 def _get_db_url(
     *, system_database_url: Optional[str], application_database_url: Optional[str]
-) -> Tuple[str, str]:
+) -> Tuple[str, str | None]:
     """
     Get the database URL to use for the DBOS application.
     Order of precedence:
@@ -287,6 +287,13 @@ def migrate(
             help="The role with which you will run your DBOS application",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -294,22 +301,30 @@ def migrate(
     )
 
     typer.echo(f"Starting DBOS migrations")
-    typer.echo(f"Application database: {sa.make_url(application_database_url)}")
+    if application_database_url:
+        typer.echo(f"Application database: {sa.make_url(application_database_url)}")
     typer.echo(f"System database: {sa.make_url(system_database_url)}")
+    if schema is None:
+        schema = "dbos"
+    typer.echo(f"DBOS system schema: {schema}")
 
     # First, run DBOS migrations on the system database and the application database
     migrate_dbos_databases(
         app_database_url=application_database_url,
         system_database_url=system_database_url,
+        schema=schema,
     )
 
     # Next, assign permissions on the DBOS schema to the application role, if any
     if application_role:
+        if application_database_url:
+            grant_dbos_schema_permissions(
+                database_url=application_database_url,
+                role_name=application_role,
+                schema=schema,
+            )
         grant_dbos_schema_permissions(
-            database_url=application_database_url, role_name=application_role
-        )
-        grant_dbos_schema_permissions(
-            database_url=system_database_url, role_name=application_role
+            database_url=system_database_url, role_name=application_role, schema=schema
         )
 
     # Next, run any custom migration commands specified in the configuration
@@ -475,6 +490,13 @@ def list(
             help="Offset for pagination",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -483,6 +505,7 @@ def list(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     workflows = client.list_workflows(
         limit=limit,
@@ -517,6 +540,13 @@ def get(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -525,6 +555,7 @@ def get(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     status = client.retrieve_workflow(workflow_id=workflow_id).get_status()
     print(json.dumps(status.__dict__, cls=DefaultEncoder))
@@ -549,6 +580,13 @@ def steps(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -557,6 +595,7 @@ def steps(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     steps = client.list_workflow_steps(workflow_id=workflow_id)
     print(json.dumps(steps, cls=DefaultEncoder))
@@ -583,6 +622,13 @@ def cancel(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -591,6 +637,7 @@ def cancel(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     client.cancel_workflow(workflow_id=workflow_id)
 
@@ -614,6 +661,13 @@ def resume(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -622,6 +676,7 @@ def resume(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     client.resume_workflow(workflow_id=workflow_id)
 
@@ -647,6 +702,13 @@ def restart(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -655,6 +717,7 @@ def restart(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     status = client.fork_workflow(workflow_id=workflow_id, start_step=1).get_status()
     print(json.dumps(status.__dict__, cls=DefaultEncoder))
@@ -705,6 +768,13 @@ def fork(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -713,6 +783,7 @@ def fork(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
 
     if forked_workflow_id is not None:
@@ -809,6 +880,13 @@ def list_queue(
             help="Offset for pagination",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -817,6 +895,7 @@ def list_queue(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     workflows = client.list_queued_workflows(
         limit=limit,

dbos/cli/migration.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import sqlalchemy as sa
 import typer
 
@@ -5,7 +7,9 @@ from dbos._app_db import ApplicationDatabase
 from dbos._sys_db import SystemDatabase
 
 
-def migrate_dbos_databases(app_database_url: str, system_database_url: str) -> None:
+def migrate_dbos_databases(
+    app_database_url: Optional[str], system_database_url: str, schema: str
+) -> None:
     app_db = None
     sys_db = None
     try:
@@ -16,17 +20,20 @@ def migrate_dbos_databases(app_database_url: str, system_database_url: str) -> N
                 "max_overflow": 0,
                 "pool_size": 2,
             },
-        )
-        app_db = ApplicationDatabase.create(
-            database_url=app_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
+            schema=schema,
         )
         sys_db.run_migrations()
-        app_db.run_migrations()
+        if app_database_url:
+            app_db = ApplicationDatabase.create(
+                database_url=app_database_url,
+                engine_kwargs={
+                    "pool_timeout": 30,
+                    "max_overflow": 0,
+                    "pool_size": 2,
+                },
+                schema=schema,
+            )
+            app_db.run_migrations()
     except Exception as e:
         typer.echo(f"DBOS migrations failed: {e}")
         raise typer.Exit(code=1)
@@ -37,12 +44,14 @@ def migrate_dbos_databases(app_database_url: str, system_database_url: str) -> N
             app_db.destroy()
 
 
-def grant_dbos_schema_permissions(database_url: str, role_name: str) -> None:
+def grant_dbos_schema_permissions(
+    database_url: str, role_name: str, schema: str
+) -> None:
     """
-    Grant all permissions on all entities in the dbos schema to the specified role.
+    Grant all permissions on all entities in the system schema to the specified role.
     """
     typer.echo(
-        f"Granting permissions for DBOS schema to {role_name} in database {sa.make_url(database_url)}"
+        f"Granting permissions for the {schema} schema to {role_name} in database {sa.make_url(database_url)}"
     )
     engine = None
     try:
@@ -52,38 +61,38 @@ def grant_dbos_schema_permissions(database_url: str, role_name: str) -> None:
         with engine.connect() as connection:
             connection.execution_options(isolation_level="AUTOCOMMIT")
 
-            # Grant usage on the dbos schema
-            sql = f'GRANT USAGE ON SCHEMA dbos TO "{role_name}"'
+            # Grant usage on the system schema
+            sql = f'GRANT USAGE ON SCHEMA "{schema}" TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant all privileges on all existing tables in dbos schema (includes views)
-            sql = f'GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA dbos TO "{role_name}"'
+            # Grant all privileges on all existing tables in the system schema (includes views)
+            sql = f'GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA "{schema}" TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant all privileges on all sequences in dbos schema
-            sql = (
-                f'GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA dbos TO "{role_name}"'
-            )
+            # Grant all privileges on all sequences in the system schema
+            sql = f'GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA "{schema}" TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant execute on all functions and procedures in dbos schema
-            sql = f'GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA dbos TO "{role_name}"'
+            # Grant execute on all functions and procedures in the system schema
+            sql = (
+                f'GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA "{schema}" TO "{role_name}"'
+            )
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant default privileges for future objects in dbos schema
-            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT ALL ON TABLES TO "{role_name}"'
+            # Grant default privileges for future objects in the system schema
+            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema}" GRANT ALL ON TABLES TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT ALL ON SEQUENCES TO "{role_name}"'
+            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema}" GRANT ALL ON SEQUENCES TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT EXECUTE ON FUNCTIONS TO "{role_name}"'
+            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema}" GRANT EXECUTE ON FUNCTIONS TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 

{dbos-1.15.0a1.dist-info → dbos-1.15.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 1.15.0a1
+Version: 1.15.0a3
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-1.15.0a1.dist-info → dbos-1.15.0a3.dist-info}/RECORD

@@ -1,20 +1,20 @@
-dbos-1.15.0a1.dist-info/METADATA,sha256=554w5m_z7LQ0LxzPVltRg_qEfahaA1NPkLDLv9g6GMY,13021
-dbos-1.15.0a1.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-dbos-1.15.0a1.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.15.0a1.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-1.15.0a3.dist-info/METADATA,sha256=Ft-tggTIl0dxVo3Byd4BKytIRVdvegchZIKPnrcnq0w,13021
+dbos-1.15.0a3.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+dbos-1.15.0a3.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.15.0a3.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=pT4BuNLDCrIQX27vQG8NlfxX6PZRU7r9miq4thJTszU,982
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=e8ELhcDWqR3_PNobnNgUvLGh5lzZq0yFSF6dvtzoQRI,16267
-dbos/_app_db.py,sha256=GsV-uYU0QsChWwQDxnrh8_iiZ_zMQB-bsP2jPGIe2aM,16094
+dbos/_app_db.py,sha256=WJwUdKsTpSZPCIWVeSF5FQNf5y1PF_lJ96tiaCjvck8,16385
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=XW5EQltqkwRgTnHq3avhuBuOTYSZkERrk9GMpqX8kfM,18859
+dbos/_client.py,sha256=Rp1OiT5523QosHB8Qy0xe9eWNx9osZGhfQknO122hj8,18928
 dbos/_conductor/conductor.py,sha256=3E_hL3c9g9yWqKZkvI6KA0-ZzPMPRo06TOzT1esMiek,24114
 dbos/_conductor/protocol.py,sha256=q3rgLxINFtWFigdOONc-4gX4vn66UmMlJQD6Kj8LnL4,7420
 dbos/_context.py,sha256=cJDxVbswTLXKE5MV4Hmg6gpIX3Dd5mBTG-4lmofWP9E,27668
-dbos/_core.py,sha256=Eec_XWwewuwyaJiQwJMv7bWBWQoC3QWXDJsm2hzUVdI,50342
+dbos/_core.py,sha256=13DNN_fpSIs42NquV80XsHV7yKwY_adKP03h_xhXok4,50493
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=dMJvLCCPqF31oqxgVF7ydcOgFmy4jRI5ky8AdMReUCQ,57987
-dbos/_dbos_config.py,sha256=B1y1hrWJc8UIoWbCqqBRGnc3bainLPp-TC6x1phInk0,25320
+dbos/_dbos.py,sha256=ReujpyRseUNL_9FQN-uIhSFh6HJnAA2IAcVy6qDdEco,58036
+dbos/_dbos_config.py,sha256=pnFeWZFDsk_94DWDCqm3e-ppTrqBFKQQdD5TvQGZ8-Y,25963
 dbos/_debouncer.py,sha256=VmGq1_ZIQ79fnH14LEhdoqxKWp6rlEwzsUwumwAMgTQ,15095
 dbos/_debug.py,sha256=0MfgNqutCUhI4PEmmra9x7f3DiFE_0nscfUCHdLimEY,1415
 dbos/_docker_pg_helper.py,sha256=xySum4hTA8TVMBODoG19u4cXQAB1vCock-jwM2pnmSI,7791
@@ -25,7 +25,7 @@ dbos/_flask.py,sha256=Npnakt-a3W5OykONFRkDRnumaDhTQmA0NPdUCGRYKXE,1652
 dbos/_kafka.py,sha256=Gm4fHWl7gYb-i5BMvwNwm5Km3z8zQpseqdMgqgFjlGI,4252
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
 dbos/_logger.py,sha256=djnCp147QoQ1iG9Bt3Uz8RyGaXGmi6gebccXsrA6Cps,4660
-dbos/_migration.py,sha256=LgxWPtXqRRwjvS5CrSvQ81B_UzLvRNWd4fnQ_Wo-gek,9507
+dbos/_migration.py,sha256=VAQxZXWQISifW0JpIG78lowV1MTBJ5ZC4P0YIwqxQhM,10013
 dbos/_outcome.py,sha256=7HvosMfEHTh1U5P6xok7kFTGLwa2lPaul0YApb3UnN4,8191
 dbos/_queue.py,sha256=0kJTPwXy3nZ4Epzt-lHky9M9S4L31645drPGFR8fIJY,4854
 dbos/_recovery.py,sha256=K-wlFhdf4yGRm6cUzyhcTjQUS0xp2T5rdNMLiiBErYg,2882
@@ -34,11 +34,11 @@ dbos/_roles.py,sha256=kCuhhg8XLtrHCgKgm44I0abIRTGHltf88OwjEKAUggk,2317
 dbos/_scheduler.py,sha256=CWeGVfl9h51VXfxt80y5Da_5pE8SPty_AYkfpJkkMxQ,2117
 dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
-dbos/_schemas/system_database.py,sha256=-dAKk-_Y3vzbpLT4ei-sIrBQgFyQiwPj1enZb1TYc8I,4943
+dbos/_schemas/system_database.py,sha256=aEkjRQDh9xjdke0d9uFx_20-c9UjQtvuLtHZ24aOypA,5497
 dbos/_serialization.py,sha256=GLgWLtHpvk7nSHyXukVQLE1ASNA3CJBtfF8w6iflBDw,3590
-dbos/_sys_db.py,sha256=SspVk-wYmE6xZLuyYQUclwh_AMjnkDXcog5g5WmYn7c,83036
-dbos/_sys_db_postgres.py,sha256=CcvxWzoByEvCZ2P_P-KNBRcyJ_8vSpCjtHBRmc7l5hI,7324
-dbos/_sys_db_sqlite.py,sha256=xT9l-czMhLmfuu5UcnBzAyUxSFgzt3XtEWx9t_D8mZs,7361
+dbos/_sys_db.py,sha256=Trlbf99KvH8YRthQ3diJQMSi0eDmky7X8dPG1wuv5VI,83098
+dbos/_sys_db_postgres.py,sha256=V3RGj2cXdCZ8xNxiMO-ECfKuHXtGZLVVNtOXtFSVHBw,7215
+dbos/_sys_db_sqlite.py,sha256=lEmJjyUHXo09q1sMpNpasurh4JyrH6DsmYzLjDC5k6Y,7091
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_templates/dbos-db-starter/__package/main.py.dbos,sha256=aQnBPSSQpkB8ERfhf7gB7P9tsU6OPKhZscfeh0yiaD8,2702
@@ -48,12 +48,12 @@ dbos/_templates/dbos-db-starter/migrations/create_table.py.dbos,sha256=pVm2Q0Asx
 dbos/_templates/dbos-db-starter/start_postgres_docker.py,sha256=lQVLlYO5YkhGPEgPqwGc7Y8uDKse9HsWv5fynJEFJHM,1681
 dbos/_tracer.py,sha256=PHbD7iTEkHk7z4B9hc-wPgi2dPTeI1rhZgLI33TQEeM,3786
 dbos/_utils.py,sha256=ZdoM1MDbHnlJrh31zfhp3iX62bAxK1kyvMwXnltC_84,1779
-dbos/_workflow_commands.py,sha256=EmmAaQfRWeOZm_WPTznuU-O3he3jiSzzT9VpYrhxugE,4835
+dbos/_workflow_commands.py,sha256=k-i1bCfNrux43BHLT8wQ-l-MVZX3D6LGZLH7-uuiDRo,4951
 dbos/cli/_github_init.py,sha256=R_94Fnn40CAmPy-zM00lwHi0ndyfv57TmIooADjmag4,3378
 dbos/cli/_template_init.py,sha256=AltKk256VocgvxLpuTxpjJyACrdHFjbGoqYhHzeLae4,2649
-dbos/cli/cli.py,sha256=-yoFUGzwPiAJlDfCOWr2TfnVw5LvMGqDKDK-ri-HPzw,26631
-dbos/cli/migration.py,sha256=5GiyagLZkyVvDz3StYxtFdkFoKFCmh6eSXjzsIGhZ_A,3330
+dbos/cli/cli.py,sha256=K8Fz05qach61EMuv5reUMRgT-UltysGZ4XerOTR4KEg,29003
+dbos/cli/migration.py,sha256=1Y52EMc2rX7PJgJa3_KXV7oiQEO569k7aHXRofwYipo,3608
 dbos/dbos-config.schema.json,sha256=LyUT1DOTaAwOP6suxQGS5KemVIqXGPyu_q7Hbo0neA8,6192
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-1.15.0a1.dist-info/RECORD,,
+dbos-1.15.0a3.dist-info/RECORD,,