dbos 1.12.0a2__py3-none-any.whl → 1.13.0__py3-none-any.whl

dbos/_dbos_config.py

@@ -22,9 +22,10 @@ class DBOSConfig(TypedDict, total=False):
 
     Attributes:
         name (str): Application name
-        database_url (str): Database connection string
-        system_database_url (str): Connection string for the system database (if different from the application database)
-        sys_db_name (str): System database name (deprecated)
+        system_database_url (str): Connection string for the DBOS system database. Defaults to sqlite:///{name} if not provided.
+        application_database_url (str): Connection string for the DBOS application database, in which DBOS @Transaction functions run. Optional. Should be the same type of database (SQLite or Postgres) as the system database.
+        database_url (str): (DEPRECATED) Database connection string
+        sys_db_name (str): (DEPRECATED) System database name
         sys_db_pool_size (int): System database pool size
         db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs (See https://docs.sqlalchemy.org/en/20/core/engines.html#sqlalchemy.create_engine)
         log_level (str): Log level
@@ -33,11 +34,15 @@ class DBOSConfig(TypedDict, total=False):
         admin_port (int): Admin port
         run_admin_server (bool): Whether to run the DBOS admin server
         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
+        disable_otlp (bool): If True, disables OTLP tracing and logging. Defaults to False.
     """
 
     name: str
-    database_url: Optional[str]
     system_database_url: Optional[str]
+    application_database_url: Optional[str]
+    database_url: Optional[str]
     sys_db_name: Optional[str]
     sys_db_pool_size: Optional[int]
     db_engine_kwargs: Optional[Dict[str, Any]]
@@ -49,6 +54,7 @@ class DBOSConfig(TypedDict, total=False):
     otlp_attributes: Optional[dict[str, str]]
     application_version: Optional[str]
     executor_id: Optional[str]
+    disable_otlp: Optional[bool]
 
 
 class RuntimeConfig(TypedDict, total=False):
@@ -91,6 +97,7 @@ class TelemetryConfig(TypedDict, total=False):
     logs: Optional[LoggerConfig]
     OTLPExporter: Optional[OTLPExporterConfig]
     otlp_attributes: Optional[dict[str, str]]
+    disable_otlp: Optional[bool]
 
 
 class ConfigFile(TypedDict, total=False):
@@ -102,12 +109,12 @@ class ConfigFile(TypedDict, total=False):
 
     Attributes:
         name (str): Application name
-        runtimeConfig (RuntimeConfig): Configuration for request serving
+        runtimeConfig (RuntimeConfig): Configuration for DBOS Cloud
         database (DatabaseConfig): Configure pool sizes, migrate commands
-        database_url (str): Database connection string
+        database_url (str): Application database URL
+        system_database_url (str): System database URL
         telemetry (TelemetryConfig): Configuration for tracing / logging
-        env (Dict[str,str]): Environment varialbes
-        application (Dict[str, Any]): Application-specific configuration section
+        env (Dict[str,str]): Environment variables
 
     """
 
@@ -139,8 +146,12 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
     if db_config:
         translated_config["database"] = db_config
 
+    # Use application_database_url instead of the deprecated database_url if provided
     if "database_url" in config:
         translated_config["database_url"] = config.get("database_url")
+    elif "application_database_url" in config:
+        translated_config["database_url"] = config.get("application_database_url")
+
     if "system_database_url" in config:
         translated_config["system_database_url"] = config.get("system_database_url")
 
@@ -157,6 +168,7 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
     telemetry: TelemetryConfig = {
         "OTLPExporter": {"tracesEndpoint": [], "logsEndpoint": []},
         "otlp_attributes": config.get("otlp_attributes", {}),
+        "disable_otlp": config.get("disable_otlp", False),
     }
     # For mypy
     assert telemetry["OTLPExporter"] is not None
@@ -227,7 +239,6 @@ def _substitute_env_vars(content: str, silent: bool = False) -> str:
 def load_config(
     config_file_path: str = DBOS_CONFIG_PATH,
     *,
-    run_process_config: bool = True,
     silent: bool = False,
 ) -> ConfigFile:
     """
@@ -277,8 +288,6 @@ def load_config(
             ]
 
     data = cast(ConfigFile, data)
-    if run_process_config:
-        data = process_config(data=data, silent=silent)
     return data  # type: ignore
 
 
@@ -290,19 +299,12 @@ def process_config(
     """
     If a database_url is provided, pass it as is in the config.
 
-    Else, build a database_url from defaults.
+    Else, default to SQLite.
 
     Also build SQL Alchemy "kwargs" base on user input + defaults.
     Specifically, db_engine_kwargs takes precedence over app_db_pool_size
 
     In debug mode, apply overrides from DBOS_DBHOST, DBOS_DBPORT, DBOS_DBUSER, and DBOS_DBPASSWORD.
-
-    Default configuration:
-        - Hostname: localhost
-        - Port: 5432
-        - Username: postgres
-        - Password: $PGPASSWORD
-        - Database name: transformed application name.
     """
 
     if "name" not in data:
@@ -334,20 +336,16 @@ def process_config(
 
     # Ensure database dict exists
     data.setdefault("database", {})
-
-    # Database URL resolution
     connect_timeout = None
-    if data.get("database_url") is not None and data["database_url"] != "":
+
+    # Process the application database URL, if provided
+    if data.get("database_url"):
         # Parse the db string and check required fields
         assert data["database_url"] is not None
         assert is_valid_database_url(data["database_url"])
 
         url = make_url(data["database_url"])
 
-        if not data["database"].get("sys_db_name"):
-            assert url.database is not None
-            data["database"]["sys_db_name"] = url.database + SystemSchema.sysdb_suffix
-
         # Gather connect_timeout from the URL if provided. It should be used in engine kwargs if not provided there (instead of our default)
         connect_timeout_str = url.query.get("connect_timeout")
         if connect_timeout_str is not None:
@@ -372,25 +370,88 @@ def process_config(
                 host=os.getenv("DBOS_DBHOST", url.host),
                 port=port,
             ).render_as_string(hide_password=False)
-    else:
+
+    # Process the system database URL, if provided
+    if data.get("system_database_url"):
+        # Parse the db string and check required fields
+        assert data["system_database_url"]
+        assert is_valid_database_url(data["system_database_url"])
+
+        url = make_url(data["system_database_url"])
+
+        # Gather connect_timeout from the URL if provided. It should be used in engine kwargs if not provided there (instead of our default). This overrides a timeout from the application database, if any.
+        connect_timeout_str = url.query.get("connect_timeout")
+        if connect_timeout_str is not None:
+            assert isinstance(
+                connect_timeout_str, str
+            ), "connect_timeout must be a string and defined once in the URL"
+            if connect_timeout_str.isdigit():
+                connect_timeout = int(connect_timeout_str)
+
+        # In debug mode perform env vars overrides
+        if isDebugMode:
+            # Override the username, password, host, and port
+            port_str = os.getenv("DBOS_DBPORT")
+            port = (
+                int(port_str)
+                if port_str is not None and port_str.isdigit()
+                else url.port
+            )
+            data["system_database_url"] = url.set(
+                username=os.getenv("DBOS_DBUSER", url.username),
+                password=os.getenv("DBOS_DBPASSWORD", url.password),
+                host=os.getenv("DBOS_DBHOST", url.host),
+                port=port,
+            ).render_as_string(hide_password=False)
+
+    # If an application database URL is provided but not the system database URL,
+    # construct the system database URL.
+    if data.get("database_url") and not data.get("system_database_url"):
+        assert data["database_url"]
+        if data["database_url"].startswith("sqlite"):
+            data["system_database_url"] = data["database_url"]
+        else:
+            url = make_url(data["database_url"])
+            assert url.database
+            if data["database"].get("sys_db_name"):
+                url = url.set(database=data["database"]["sys_db_name"])
+            else:
+                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 data.get("system_database_url") and not data.get("database_url"):
+        assert data["system_database_url"]
+        data["database_url"] = data["system_database_url"]
+
+    # If neither URL is provided, use a default SQLite 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"])
-        _password = os.environ.get("PGPASSWORD", "dbos")
-        data["database_url"] = (
-            f"postgres://postgres:{_password}@localhost:5432/{_app_db_name}?connect_timeout=10&sslmode=prefer"
+        data["system_database_url"] = data["database_url"] = (
+            f"sqlite:///{_app_db_name}.sqlite"
         )
-        if not data["database"].get("sys_db_name"):
-            data["database"]["sys_db_name"] = _app_db_name + SystemSchema.sysdb_suffix
-        assert data["database_url"] is not None
 
     configure_db_engine_parameters(data["database"], connect_timeout=connect_timeout)
 
-    # Pretty-print where we've loaded database connection information from, respecting the log level
+    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":
-        log_url = make_url(data["database_url"]).render_as_string(hide_password=True)
-        print(f"[bold blue]Using database connection string: {log_url}[/bold blue]")
+        printable_sys_db_url = make_url(data["system_database_url"]).render_as_string(
+            hide_password=True
+        )
         print(
-            f"[bold blue]Database engine parameters: {data['database']['db_engine_kwargs']}[/bold blue]"
+            f"[bold blue]DBOS system database URL: {printable_sys_db_url}[/bold blue]"
         )
+        if data["database_url"].startswith("sqlite"):
+            print(
+                f"[bold blue]Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use.[/bold blue]"
+            )
+        else:
+            print(
+                f"[bold blue]Database engine parameters: {data['database']['db_engine_kwargs']}[/bold blue]"
+            )
 
     # Return data as ConfigFile type
     return data
@@ -439,6 +500,8 @@ def configure_db_engine_parameters(
 
 
 def is_valid_database_url(database_url: str) -> bool:
+    if database_url.startswith("sqlite"):
+        return True
     url = make_url(database_url)
     required_fields = [
         ("username", "Username must be specified in the connection URL"),
@@ -467,36 +530,34 @@ def _app_name_to_db_name(app_name: str) -> str:
 
 def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
     # Load the DBOS configuration file and force the use of:
-    # 1. The database url provided by DBOS_DATABASE_URL
+    # 1. The application and system database url provided by DBOS_DATABASE_URL and DBOS_SYSTEM_DATABASE_URL
     # 2. OTLP traces endpoints (add the config data to the provided config)
     # 3. Use the application name from the file. This is a defensive measure to ensure the application name is whatever it was registered with in the cloud
     # 4. Remove admin_port is provided in code
     # 5. Remove env vars if provided in code
     # Optimistically assume that expected fields in config_from_file are present
 
-    config_from_file = load_config(run_process_config=False)
+    config_from_file = load_config()
     # Be defensive
     if config_from_file is None:
         return provided_config
 
-    # Name
+    # Set the application name to the cloud app name
     provided_config["name"] = config_from_file["name"]
 
-    # Database config. Expects DBOS_DATABASE_URL to be set
-    if "database" not in provided_config:
-        provided_config["database"] = {}
-    provided_config["database"]["sys_db_name"] = config_from_file["database"][
-        "sys_db_name"
-    ]
-
+    # Use the DBOS Cloud application and system database URLs
     db_url = os.environ.get("DBOS_DATABASE_URL")
     if db_url is None:
         raise DBOSInitializationError(
             "DBOS_DATABASE_URL environment variable is not set. This is required to connect to the database."
         )
     provided_config["database_url"] = db_url
-    if "system_database_url" in provided_config:
-        del provided_config["system_database_url"]
+    system_db_url = os.environ.get("DBOS_SYSTEM_DATABASE_URL")
+    if system_db_url is None:
+        raise DBOSInitializationError(
+            "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
 
     # Telemetry config
     if "telemetry" not in provided_config or provided_config["telemetry"] is None:
@@ -553,8 +614,10 @@ def get_system_database_url(config: ConfigFile) -> str:
         return config["system_database_url"]
     else:
         assert config["database_url"] is not None
+        if config["database_url"].startswith("sqlite"):
+            return config["database_url"]
         app_db_url = make_url(config["database_url"])
-        if config["database"].get("sys_db_name") is not None:
+        if config.get("database") and config["database"].get("sys_db_name") is not None:
             sys_db_name = config["database"]["sys_db_name"]
         else:
             assert app_db_url.database is not None
@@ -562,3 +625,14 @@ def get_system_database_url(config: ConfigFile) -> str:
         return app_db_url.set(database=sys_db_name).render_as_string(
             hide_password=False
         )
+
+
+def get_application_database_url(config: ConfigFile) -> str:
+    # 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"]

dbos/_fastapi.py

@@ -49,7 +49,7 @@ class LifespanMiddleware:
                     if not self.dbos._launched:
                         self.dbos._launch()
                 elif message["type"] == "lifespan.shutdown.complete":
-                    self.dbos._destroy()
+                    self.dbos.destroy()
                 await send(message)
 
             # Call the original app with our wrapped functions
@@ -83,4 +83,6 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
                     response = await call_next(request)
             else:
                 response = await call_next(request)
+            if hasattr(response, "status_code"):
+                DBOS.span.set_attribute("responseCode", response.status_code)
         return response

dbos/_logger.py

@@ -77,7 +77,9 @@ def config_logger(config: "ConfigFile") -> None:
     otlp_logs_endpoints = (
         config.get("telemetry", {}).get("OTLPExporter", {}).get("logsEndpoint")  # type: ignore
     )
-    if otlp_logs_endpoints:
+    disable_otlp = config.get("telemetry", {}).get("disable_otlp", False)  # type: ignore
+
+    if not disable_otlp and otlp_logs_endpoints:
         log_provider = PatchedOTLPLoggerProvider(
             Resource.create(
                 attributes={

dbos/_migration.py

@@ -0,0 +1,322 @@
+import logging
+import os
+import re
+import sys
+
+import sqlalchemy as sa
+from alembic import command
+from alembic.config import Config
+
+from ._logger import dbos_logger
+
+
+def ensure_dbos_schema(engine: sa.Engine) -> bool:
+    """
+    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)
+    """
+    with engine.begin() as conn:
+        # Check if dbos schema exists
+        schema_result = conn.execute(
+            sa.text(
+                "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'dbos'"
+            )
+        )
+        schema_existed = schema_result.fetchone() is not None
+
+        # Create schema if it doesn't exist
+        if not schema_existed:
+            conn.execute(sa.text("CREATE SCHEMA dbos"))
+
+        # 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'"
+            )
+        )
+        table_exists = table_result.fetchone() is not None
+
+        if table_exists:
+            return True
+        elif schema_existed:
+            return False
+        else:
+            conn.execute(
+                sa.text(
+                    "CREATE TABLE dbos.dbos_migrations (version BIGINT NOT NULL PRIMARY KEY)"
+                )
+            )
+            return True
+
+
+def run_alembic_migrations(engine: sa.Engine) -> None:
+    """Run system database schema migrations with Alembic.
+    This is DEPRECATED in favor of DBOS-managed migrations.
+    It is retained only for backwards compatibility and
+    will be removed in the next major version."""
+    # Run a schema migration for the system database
+    migration_dir = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)), "_alembic_migrations"
+    )
+    alembic_cfg = Config()
+    alembic_cfg.set_main_option("script_location", migration_dir)
+    logging.getLogger("alembic").setLevel(logging.WARNING)
+    # Alembic requires the % in URL-escaped parameters to itself be escaped to %%.
+    escaped_conn_string = re.sub(
+        r"%(?=[0-9A-Fa-f]{2})",
+        "%%",
+        engine.url.render_as_string(hide_password=False),
+    )
+    alembic_cfg.set_main_option("sqlalchemy.url", escaped_conn_string)
+    try:
+        command.upgrade(alembic_cfg, "head")
+    except Exception as e:
+        dbos_logger.warning(
+            f"Exception during system database construction. This is most likely because the system database was configured using a later version of DBOS: {e}"
+        )
+
+
+def run_dbos_migrations(engine: sa.Engine) -> 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"))
+        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):
+            if i <= last_applied:
+                continue
+
+            # Execute the migration
+            dbos_logger.info(f"Applying DBOS system database schema migration {i}")
+            conn.execute(sa.text(migration_sql))
+
+            # Update the single row with the new version
+            if last_applied == 0:
+                conn.execute(
+                    sa.text(
+                        "INSERT INTO dbos.dbos_migrations (version) VALUES (:version)"
+                    ),
+                    {"version": i},
+                )
+            else:
+                conn.execute(
+                    sa.text("UPDATE dbos.dbos_migrations SET version = :version"),
+                    {"version": i},
+                )
+            last_applied = i
+
+
+dbos_migration_one = """
+-- Enable uuid extension for generating UUIDs
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+CREATE TABLE dbos.workflow_status (
+    workflow_uuid TEXT PRIMARY KEY,
+    status TEXT,
+    name TEXT,
+    authenticated_user TEXT,
+    assumed_role TEXT,
+    authenticated_roles TEXT,
+    request TEXT,
+    output TEXT,
+    error TEXT,
+    executor_id TEXT,
+    created_at BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
+    updated_at BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
+    application_version TEXT,
+    application_id TEXT,
+    class_name VARCHAR(255) DEFAULT NULL,
+    config_name VARCHAR(255) DEFAULT NULL,
+    recovery_attempts BIGINT DEFAULT 0,
+    queue_name TEXT,
+    workflow_timeout_ms BIGINT,
+    workflow_deadline_epoch_ms BIGINT,
+    inputs TEXT,
+    started_at_epoch_ms BIGINT,
+    deduplication_id TEXT,
+    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);
+
+ALTER TABLE dbos.workflow_status 
+ADD CONSTRAINT uq_workflow_status_queue_name_dedup_id 
+UNIQUE (queue_name, deduplication_id);
+
+CREATE TABLE dbos.operation_outputs (
+    workflow_uuid TEXT NOT NULL,
+    function_id INTEGER NOT NULL,
+    function_name TEXT NOT NULL DEFAULT '',
+    output TEXT,
+    error TEXT,
+    child_workflow_id TEXT,
+    PRIMARY KEY (workflow_uuid, function_id),
+    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE dbos.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) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX idx_workflow_topic ON dbos.notifications (destination_uuid, topic);
+
+-- Create notification function
+CREATE OR REPLACE FUNCTION dbos.notifications_function() RETURNS TRIGGER AS $$
+DECLARE
+    payload text := NEW.destination_uuid || '::' || NEW.topic;
+BEGIN
+    PERFORM pg_notify('dbos_notifications_channel', payload);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create notification trigger
+CREATE TRIGGER dbos_notifications_trigger
+AFTER INSERT ON dbos.notifications
+FOR EACH ROW EXECUTE FUNCTION dbos.notifications_function();
+
+CREATE TABLE dbos.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) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+-- Create events function
+CREATE OR REPLACE FUNCTION dbos.workflow_events_function() RETURNS TRIGGER AS $$
+DECLARE
+    payload text := NEW.workflow_uuid || '::' || NEW.key;
+BEGIN
+    PERFORM pg_notify('dbos_workflow_events_channel', payload);
+    RETURN NEW;
+END;
+$$ 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();
+
+CREATE TABLE dbos.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) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE dbos.event_dispatch_kv (
+    service_name TEXT NOT NULL,
+    workflow_fn_name TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT,
+    update_seq NUMERIC(38,0),
+    update_time NUMERIC(38,15),
+    PRIMARY KEY (service_name, workflow_fn_name, key)
+);
+"""
+
+
+def get_sqlite_timestamp_expr() -> str:
+    """Get SQLite timestamp expression with millisecond precision for Python >= 3.12."""
+    if sys.version_info >= (3, 12):
+        return "(unixepoch('subsec') * 1000)"
+    else:
+        return "(strftime('%s','now') * 1000)"
+
+
+sqlite_migration_one = f"""
+CREATE TABLE workflow_status (
+    workflow_uuid TEXT PRIMARY KEY,
+    status TEXT,
+    name TEXT,
+    authenticated_user TEXT,
+    assumed_role TEXT,
+    authenticated_roles TEXT,
+    request TEXT,
+    output TEXT,
+    error TEXT,
+    executor_id TEXT,
+    created_at INTEGER NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+    updated_at INTEGER NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+    application_version TEXT,
+    application_id TEXT,
+    class_name TEXT DEFAULT NULL,
+    config_name TEXT DEFAULT NULL,
+    recovery_attempts INTEGER DEFAULT 0,
+    queue_name TEXT,
+    workflow_timeout_ms INTEGER,
+    workflow_deadline_epoch_ms INTEGER,
+    inputs TEXT,
+    started_at_epoch_ms INTEGER,
+    deduplication_id TEXT,
+    priority INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX workflow_status_created_at_index ON workflow_status (created_at);
+CREATE INDEX workflow_status_executor_id_index ON workflow_status (executor_id);
+CREATE INDEX workflow_status_status_index ON workflow_status (status);
+
+CREATE UNIQUE INDEX uq_workflow_status_queue_name_dedup_id 
+ON workflow_status (queue_name, deduplication_id);
+
+CREATE TABLE operation_outputs (
+    workflow_uuid TEXT NOT NULL,
+    function_id INTEGER NOT NULL,
+    function_name TEXT NOT NULL DEFAULT '',
+    output TEXT,
+    error TEXT,
+    child_workflow_id TEXT,
+    PRIMARY KEY (workflow_uuid, function_id),
+    FOREIGN KEY (workflow_uuid) REFERENCES workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE notifications (
+    destination_uuid TEXT NOT NULL,
+    topic TEXT,
+    message TEXT NOT NULL,
+    created_at_epoch_ms INTEGER NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+    message_uuid TEXT NOT NULL DEFAULT (hex(randomblob(16))),
+    FOREIGN KEY (destination_uuid) REFERENCES workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX idx_workflow_topic ON notifications (destination_uuid, topic);
+
+CREATE TABLE 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 workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE 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 workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+"""
+
+dbos_migrations = [dbos_migration_one]
+sqlite_migrations = [sqlite_migration_one]