dbos 0.25.0a1__tar.gz → 0.25.0a7__tar.gz

{dbos-0.25.0a1 → dbos-0.25.0a7}/PKG-INFO

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

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/__main__.py

@@ -4,6 +4,9 @@ from typing import NoReturn, Optional, Union
 
 from dbos.cli.cli import app
 
+# This is used by the debugger to execute DBOS as a module.
+# Never used otherwise.
+
 
 def main() -> NoReturn:
     # Modify sys.argv[0] to remove script or executable extensions

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_admin_server.py

@@ -7,6 +7,8 @@ from functools import partial
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import TYPE_CHECKING, Any, List, TypedDict
 
+import jsonpickle  # type: ignore
+
 from ._logger import dbos_logger
 from ._recovery import recover_pending_workflows
 
@@ -20,6 +22,7 @@ _workflow_queues_metadata_path = "/dbos-workflow-queues-metadata"
 # /workflows/:workflow_id/cancel
 # /workflows/:workflow_id/resume
 # /workflows/:workflow_id/restart
+# /workflows/:workflow_id/steps
 
 
 class AdminServer:
@@ -86,8 +89,16 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self._end_headers()
             self.wfile.write(json.dumps(queue_metadata_array).encode("utf-8"))
         else:
-            self.send_response(404)
-            self._end_headers()
+            steps_match = re.match(
+                r"^/workflows/(?P<workflow_id>[^/]+)/steps$", self.path
+            )
+
+            if steps_match:
+                workflow_id = steps_match.group("workflow_id")
+                self._handle_steps(workflow_id)
+            else:
+                self.send_response(404)
+                self._end_headers()
 
     def do_POST(self) -> None:
         content_length = int(
@@ -149,6 +160,13 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         self.send_response(204)
         self._end_headers()
 
+    def _handle_steps(self, workflow_id: str) -> None:
+        steps = self.dbos._sys_db.get_workflow_steps(workflow_id)
+        json_steps = jsonpickle.encode(steps, unpicklable=False).encode("utf-8")
+        self.send_response(200)
+        self._end_headers()
+        self.wfile.write(json_steps)
+
 
 # Be consistent with DBOS-TS response.
 class PerfUtilization(TypedDict):

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_context.py

@@ -92,6 +92,9 @@ class DBOSContext:
         rv.assumed_role = self.assumed_role
         return rv
 
+    def has_parent(self) -> bool:
+        return len(self.parent_workflow_id) > 0
+
     def assign_workflow_id(self) -> str:
         if len(self.id_assigned_for_next_workflow) > 0:
             wfid = self.id_assigned_for_next_workflow

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_core.py

@@ -243,12 +243,15 @@ def _init_workflow(
             wf_status = dbos._sys_db.insert_workflow_status(
                 status, max_recovery_attempts=max_recovery_attempts
             )
+
             # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
             dbos._sys_db.update_workflow_inputs(
                 wfid, _serialization.serialize_args(inputs)
             )
+
         else:
             # Buffer the inputs for single-transaction workflows, but don't buffer the status
+
             dbos._sys_db.buffer_workflow_inputs(
                 wfid, _serialization.serialize_args(inputs)
             )
@@ -475,6 +478,15 @@ def start_workflow(
 
     new_wf_id, new_wf_ctx = _get_new_wf()
 
+    ctx = new_wf_ctx
+    new_child_workflow_id = ctx.id_assigned_for_next_workflow
+    if ctx.has_parent():
+        child_workflow_id = dbos._sys_db.check_child_workflow(
+            ctx.parent_workflow_id, ctx.parent_workflow_fid
+        )
+        if child_workflow_id is not None:
+            return WorkflowHandlePolling(child_workflow_id, dbos)
+
     status = _init_workflow(
         dbos,
         new_wf_ctx,
@@ -488,6 +500,13 @@ def start_workflow(
     )
 
     wf_status = status["status"]
+    if ctx.has_parent():
+        dbos._sys_db.record_child_workflow(
+            ctx.parent_workflow_id,
+            new_child_workflow_id,
+            ctx.parent_workflow_fid,
+            func.__name__,
+        )
 
     if not execute_workflow or (
         not dbos.debug_mode
@@ -544,6 +563,17 @@ async def start_workflow_async(
 
     new_wf_id, new_wf_ctx = _get_new_wf()
 
+    ctx = new_wf_ctx
+    new_child_workflow_id = ctx.id_assigned_for_next_workflow
+    if ctx.has_parent():
+        child_workflow_id = await asyncio.to_thread(
+            dbos._sys_db.check_child_workflow,
+            ctx.parent_workflow_id,
+            ctx.parent_workflow_fid,
+        )
+        if child_workflow_id is not None:
+            return WorkflowHandleAsyncPolling(child_workflow_id, dbos)
+
     status = await asyncio.to_thread(
         _init_workflow,
         dbos,
@@ -557,6 +587,15 @@ async def start_workflow_async(
         max_recovery_attempts=fi.max_recovery_attempts,
     )
 
+    if ctx.has_parent():
+        await asyncio.to_thread(
+            dbos._sys_db.record_child_workflow,
+            ctx.parent_workflow_id,
+            new_child_workflow_id,
+            ctx.parent_workflow_fid,
+            func.__name__,
+        )
+
     wf_status = status["status"]
 
     if not execute_workflow or (
@@ -599,6 +638,8 @@ def workflow_wrapper(
 ) -> Callable[P, R]:
     func.__orig_func = func  # type: ignore
 
+    funcName = func.__name__
+
     fi = get_or_create_func_info(func)
     fi.max_recovery_attempts = max_recovery_attempts
 
@@ -629,7 +670,24 @@ def workflow_wrapper(
         wfOutcome = Outcome[R].make(functools.partial(func, *args, **kwargs))
 
         def init_wf() -> Callable[[Callable[[], R]], R]:
+
+            def recorded_result(
+                c_wfid: str, dbos: "DBOS"
+            ) -> Callable[[Callable[[], R]], R]:
+                def recorded_result_inner(func: Callable[[], R]) -> R:
+                    return WorkflowHandlePolling(c_wfid, dbos).get_result()
+
+                return recorded_result_inner
+
             ctx = assert_current_dbos_context()  # Now the child ctx
+
+            if ctx.has_parent():
+                child_workflow_id = dbos._sys_db.check_child_workflow(
+                    ctx.parent_workflow_id, ctx.parent_workflow_fid
+                )
+                if child_workflow_id is not None:
+                    return recorded_result(child_workflow_id, dbos)
+
             status = _init_workflow(
                 dbos,
                 ctx,
@@ -640,11 +698,20 @@ def workflow_wrapper(
                 temp_wf_type=get_temp_workflow_type(func),
                 max_recovery_attempts=max_recovery_attempts,
             )
+
             # TODO: maybe modify the parameters if they've been changed by `_init_workflow`
             dbos.logger.debug(
                 f"Running workflow, id: {ctx.workflow_id}, name: {get_dbos_func_name(func)}"
             )
 
+            if ctx.has_parent():
+                dbos._sys_db.record_child_workflow(
+                    ctx.parent_workflow_id,
+                    ctx.workflow_id,
+                    ctx.parent_workflow_fid,
+                    funcName,
+                )
+
             return _get_wf_invoke_func(dbos, status)
 
         outcome = (
@@ -853,6 +920,8 @@ def decorate_step(
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorator(func: Callable[P, R]) -> Callable[P, R]:
 
+        stepName = func.__name__
+
         def invoke_step(*args: Any, **kwargs: Any) -> Any:
             if dbosreg.dbos is None:
                 raise DBOSException(
@@ -897,19 +966,20 @@ def decorate_step(
                 step_output: OperationResultInternal = {
                     "workflow_uuid": ctx.workflow_id,
                     "function_id": ctx.function_id,
+                    "function_name": stepName,
                     "output": None,
                     "error": None,
                 }
 
                 try:
                     output = func()
-                    step_output["output"] = _serialization.serialize(output)
-                    return output
                 except Exception as error:
                     step_output["error"] = _serialization.serialize_exception(error)
-                    raise
-                finally:
                     dbos._sys_db.record_operation_result(step_output)
+                    raise
+                step_output["output"] = _serialization.serialize(output)
+                dbos._sys_db.record_operation_result(step_output)
+                return output
 
             def check_existing_result() -> Union[NoResult, R]:
                 ctx = assert_current_dbos_context()

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_db_wizard.py

@@ -49,6 +49,7 @@ def db_wizard(config: "ConfigFile") -> "ConfigFile":
 
     # 2. If the error is due to password authentication or the configuration is non-default, surface the error and exit.
     error_str = str(db_connection_error)
+    dbos_logger.debug(f"Error connecting to Postgres: {error_str}")
     if (
         "password authentication failed" in error_str
         or "28P01" in error_str
@@ -182,17 +183,12 @@ def _check_db_connectivity(config: "ConfigFile") -> Optional[Exception]:
         host=config["database"]["hostname"],
         port=config["database"]["port"],
         database="postgres",
-        query={"connect_timeout": "1"},
+        query={"connect_timeout": "2"},
     )
     postgres_db_engine = create_engine(postgres_db_url)
     try:
         with postgres_db_engine.connect() as conn:
-            val = conn.execute(text("SELECT 1")).scalar()
-            if val != 1:
-                dbos_logger.error(
-                    f"Unexpected value returned from database: expected 1, received {val}"
-                )
-                return Exception()
+            conn.execute(text("SELECT 1")).scalar()
     except Exception as e:
         return e
     finally:

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_dbos.py

@@ -39,6 +39,7 @@ from dbos._utils import GlobalParams
 from ._classproperty import classproperty
 from ._core import (
     TEMP_SEND_WF_NAME,
+    WorkflowHandleAsyncPolling,
     WorkflowHandlePolling,
     decorate_step,
     decorate_transaction,
@@ -757,6 +758,44 @@ class DBOS:
             ),
         )
 
+    @classmethod
+    async def get_workflow_status_async(
+        cls, workflow_id: str
+    ) -> Optional[WorkflowStatus]:
+        """Return the status of a workflow execution."""
+        ctx = get_local_dbos_context()
+        if ctx and ctx.is_within_workflow():
+            ctx.function_id += 1
+            stat = await asyncio.to_thread(
+                lambda: _get_dbos_instance()._sys_db.get_workflow_status_within_wf(
+                    workflow_id, ctx.workflow_id, ctx.function_id
+                )
+            )
+        else:
+            stat = await asyncio.to_thread(
+                lambda: _get_dbos_instance()._sys_db.get_workflow_status(workflow_id)
+            )
+        if stat is None:
+            return None
+
+        return WorkflowStatus(
+            workflow_id=workflow_id,
+            status=stat["status"],
+            name=stat["name"],
+            executor_id=stat["executor_id"],
+            recovery_attempts=stat["recovery_attempts"],
+            class_name=stat["class_name"],
+            config_name=stat["config_name"],
+            queue_name=stat["queue_name"],
+            authenticated_user=stat["authenticated_user"],
+            assumed_role=stat["assumed_role"],
+            authenticated_roles=(
+                json.loads(stat["authenticated_roles"])
+                if stat["authenticated_roles"] is not None
+                else None
+            ),
+        )
+
     @classmethod
     def retrieve_workflow(
         cls, workflow_id: str, existing_workflow: bool = True
@@ -769,6 +808,18 @@ class DBOS:
                 raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandlePolling(workflow_id, dbos)
 
+    @classmethod
+    async def retrieve_workflow_async(
+        cls, workflow_id: str, existing_workflow: bool = True
+    ) -> WorkflowHandleAsync[R]:
+        """Return a `WorkflowHandle` for a workflow execution."""
+        dbos = _get_dbos_instance()
+        if existing_workflow:
+            stat = await dbos.get_workflow_status_async(workflow_id)
+            if stat is None:
+                raise DBOSNonExistentWorkflowError(workflow_id)
+        return WorkflowHandleAsyncPolling(workflow_id, dbos)
+
     @classmethod
     def send(
         cls, destination_id: str, message: Any, topic: Optional[str] = None

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_dbos_config.py

@@ -512,7 +512,8 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
         "sys_db_name"
     ]
     provided_config["database"]["ssl"] = config_from_file["database"]["ssl"]
-    provided_config["database"]["ssl_ca"] = config_from_file["database"]["ssl_ca"]
+    if "ssl_ca" in config_from_file["database"]:
+        provided_config["database"]["ssl_ca"] = config_from_file["database"]["ssl_ca"]
 
     # Telemetry config
     if "telemetry" not in provided_config or provided_config["telemetry"] is None:

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_fastapi.py

@@ -63,7 +63,10 @@ class LifespanMiddleware:
         if scope["type"] == "lifespan":
 
             async def wrapped_send(message: MutableMapping[str, Any]) -> None:
-                if message["type"] == "lifespan.startup.complete":
+                if (
+                    message["type"] == "lifespan.startup.complete"
+                    and not self.dbos._launched
+                ):
                     self.dbos._launch()
                 elif message["type"] == "lifespan.shutdown.complete":
                     self.dbos._destroy()

dbos-0.25.0a7/dbos/_migrations/versions/f4b9b32ba814_functionname_childid_op_outputs.py

@@ -0,0 +1,46 @@
+"""functionname_childid_op_outputs
+
+Revision ID: f4b9b32ba814
+Revises: 04ca4f231047
+Create Date: 2025-03-21 14:32:43.091074
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "f4b9b32ba814"
+down_revision: Union[str, None] = "04ca4f231047"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "operation_outputs",
+        sa.Column(
+            "function_name",
+            sa.Text(),
+            nullable=False,
+            default="",
+        ),
+        schema="dbos",
+    )
+
+    op.add_column(
+        "operation_outputs",
+        sa.Column(
+            "child_workflow_id",
+            sa.Text(),
+            nullable=True,
+        ),
+        schema="dbos",
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("operation_outputs", "function_name", schema="dbos")
+    op.drop_column("operation_outputs", "child_workflow_id", schema="dbos")

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_schemas/system_database.py

@@ -71,8 +71,10 @@ class SystemSchema:
             nullable=False,
         ),
         Column("function_id", Integer, nullable=False),
+        Column("function_name", Text, nullable=False, default=""),
         Column("output", Text, nullable=True),
         Column("error", Text, nullable=True),
+        Column("child_workflow_id", Text, nullable=True),
         PrimaryKeyConstraint("workflow_uuid", "function_id"),
     )
 

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_sys_db.py

@@ -28,6 +28,7 @@ from sqlalchemy.sql import func
 from dbos._utils import GlobalParams
 
 from . import _serialization
+from ._context import get_local_dbos_context
 from ._dbos_config import ConfigFile
 from ._error import (
     DBOSConflictingWorkflowError,
@@ -89,6 +90,7 @@ class RecordedResult(TypedDict):
 class OperationResultInternal(TypedDict):
     workflow_uuid: str
     function_id: int
+    function_name: str
     output: Optional[str]  # JSON (jsonpickle)
     error: Optional[str]  # JSON (jsonpickle)
 
@@ -151,6 +153,14 @@ class GetPendingWorkflowsOutput:
         self.queue_name: Optional[str] = queue_name
 
 
+class StepInfo(TypedDict):
+    function_id: int
+    function_name: str
+    output: Optional[str]  # JSON (jsonpickle)
+    error: Optional[str]  # JSON (jsonpickle)
+    child_workflow_id: Optional[str]
+
+
 _dbos_null_topic = "__null__topic__"
 _buffer_flush_batch_size = 100
 _buffer_flush_interval_secs = 1.0
@@ -550,6 +560,7 @@ class SystemDatabase:
             {
                 "workflow_uuid": calling_wf,
                 "function_id": calling_wf_fn,
+                "function_name": "DBOS.getStatus",
                 "output": _serialization.serialize(stat),
                 "error": None,
             }
@@ -771,6 +782,28 @@ class SystemDatabase:
                 for row in rows
             ]
 
+    def get_workflow_steps(self, workflow_id: str) -> List[StepInfo]:
+        with self.engine.begin() as c:
+            rows = c.execute(
+                sa.select(
+                    SystemSchema.operation_outputs.c.function_id,
+                    SystemSchema.operation_outputs.c.function_name,
+                    SystemSchema.operation_outputs.c.output,
+                    SystemSchema.operation_outputs.c.error,
+                    SystemSchema.operation_outputs.c.child_workflow_id,
+                ).where(SystemSchema.operation_outputs.c.workflow_uuid == workflow_id)
+            ).fetchall()
+            return [
+                StepInfo(
+                    function_id=row[0],
+                    function_name=row[1],
+                    output=row[2],  # Preserve JSON data
+                    error=row[3],
+                    child_workflow_id=row[4],
+                )
+                for row in rows
+            ]
+
     def record_operation_result(
         self, result: OperationResultInternal, conn: Optional[sa.Connection] = None
     ) -> None:
@@ -782,6 +815,7 @@ class SystemDatabase:
         sql = pg.insert(SystemSchema.operation_outputs).values(
             workflow_uuid=result["workflow_uuid"],
             function_id=result["function_id"],
+            function_name=result["function_name"],
             output=output,
             error=error,
         )
@@ -796,6 +830,30 @@ class SystemDatabase:
                 raise DBOSWorkflowConflictIDError(result["workflow_uuid"])
             raise
 
+    def record_child_workflow(
+        self,
+        parentUUID: str,
+        childUUID: str,
+        functionID: int,
+        functionName: str,
+    ) -> None:
+        if self._debug_mode:
+            raise Exception("called record_child_workflow in debug mode")
+
+        sql = pg.insert(SystemSchema.operation_outputs).values(
+            workflow_uuid=parentUUID,
+            function_id=functionID,
+            function_name=functionName,
+            child_workflow_id=childUUID,
+        )
+        try:
+            with self.engine.begin() as c:
+                c.execute(sql)
+        except DBAPIError as dbapi_error:
+            if dbapi_error.orig.sqlstate == "23505":  # type: ignore
+                raise DBOSWorkflowConflictIDError(parentUUID)
+            raise
+
     def check_operation_execution(
         self, workflow_uuid: str, function_id: int, conn: Optional[sa.Connection] = None
     ) -> Optional[RecordedResult]:
@@ -822,6 +880,23 @@ class SystemDatabase:
         }
         return result
 
+    def check_child_workflow(
+        self, workflow_uuid: str, function_id: int
+    ) -> Optional[str]:
+        sql = sa.select(SystemSchema.operation_outputs.c.child_workflow_id).where(
+            SystemSchema.operation_outputs.c.workflow_uuid == workflow_uuid,
+            SystemSchema.operation_outputs.c.function_id == function_id,
+        )
+
+        # If in a transaction, use the provided connection
+        row: Any
+        with self.engine.begin() as c:
+            row = c.execute(sql).fetchone()
+
+        if row is None:
+            return None
+        return str(row[0])
+
     def send(
         self,
         workflow_uuid: str,
@@ -866,6 +941,7 @@ class SystemDatabase:
             output: OperationResultInternal = {
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
+                "function_name": "DBOS.send",
                 "output": None,
                 "error": None,
             }
@@ -959,6 +1035,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": workflow_uuid,
                     "function_id": function_id,
+                    "function_name": "DBOS.recv",
                     "output": _serialization.serialize(
                         message
                     ),  # None will be serialized to 'null'
@@ -1049,6 +1126,7 @@ class SystemDatabase:
                     {
                         "workflow_uuid": workflow_uuid,
                         "function_id": function_id,
+                        "function_name": "DBOS.sleep",
                         "output": _serialization.serialize(end_time),
                         "error": None,
                     }
@@ -1096,6 +1174,7 @@ class SystemDatabase:
             output: OperationResultInternal = {
                 "workflow_uuid": workflow_uuid,
                 "function_id": function_id,
+                "function_name": "DBOS.setEvent",
                 "output": None,
                 "error": None,
             }
@@ -1176,6 +1255,7 @@ class SystemDatabase:
                 {
                     "workflow_uuid": caller_ctx["workflow_uuid"],
                     "function_id": caller_ctx["function_id"],
+                    "function_name": "DBOS.getEvent",
                     "output": _serialization.serialize(
                         value
                     ),  # None will be serialized to 'null'

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_templates/dbos-db-starter/__package/main.py

@@ -6,6 +6,7 @@
 
 # First, let's do imports, create a FastAPI app, and initialize DBOS.
 
+import uvicorn
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
 
@@ -37,7 +38,7 @@ def example_transaction(name: str) -> str:
     return greeting
 
 
-# Finally, let's use FastAPI to serve an HTML + CSS readme
+# Now, let's use FastAPI to serve an HTML + CSS readme
 # from the root path.
 
 
@@ -66,14 +67,8 @@ def readme() -> HTMLResponse:
     return HTMLResponse(readme)
 
 
-# To deploy this app to DBOS Cloud:
-# - "npm i -g @dbos-inc/dbos-cloud@latest" to install the Cloud CLI (requires Node)
-# - "dbos-cloud app deploy" to deploy your app
-# - Deploy outputs a URL--visit it to see your app!
+# Finally, we'll launch DBOS then start the FastAPI server.
 
-
-# To run this app locally:
-# - Make sure you have a Postgres database to connect to
-# - "dbos migrate" to set up your database tables
-# - "dbos start" to start the app
-# - Visit localhost:8000 to see your app!
+if __name__ == "__main__":
+    DBOS.launch()
+    uvicorn.run(app, host="0.0.0.0", port=8000)

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_templates/dbos-db-starter/dbos-config.yaml.dbos

@@ -7,8 +7,6 @@ name: ${project_name}
 language: python
 runtimeConfig:
   start:
-    - "fastapi run ${package_name}/main.py"
+    - "${start_command}"
 database_url: ${DBOS_DATABASE_URL}
-database:
-  migrate:
-    - ${migration_command}
+${migration_section}

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/_workflow_commands.py

@@ -5,6 +5,7 @@ from ._sys_db import (
     GetQueuedWorkflowsInput,
     GetWorkflowsInput,
     GetWorkflowsOutput,
+    StepInfo,
     SystemDatabase,
     WorkflowStatuses,
 )
@@ -146,3 +147,8 @@ def get_workflow(
         winfo.request = None
 
     return winfo
+
+
+def list_workflow_steps(sys_db: SystemDatabase, workflow_uuid: str) -> List[StepInfo]:
+    output = sys_db.get_workflow_steps(workflow_uuid)
+    return output

{dbos-0.25.0a1 → dbos-0.25.0a7}/dbos/cli/_template_init.py

@@ -58,15 +58,20 @@ def copy_template(src_dir: str, project_name: str, config_mode: bool) -> None:
     dst_dir = path.abspath(".")
 
     package_name = project_name.replace("-", "_")
+    default_migration_section = """database:
+  migrate:
+    - alembic upgrade head
+"""
     ctx = {
         "project_name": project_name,
         "package_name": package_name,
-        "migration_command": "alembic upgrade head",
+        "start_command": f"python3 -m {package_name}.main",
+        "migration_section": default_migration_section,
     }
 
     if config_mode:
-        ctx["package_name"] = "."
-        ctx["migration_command"] = "echo 'No migrations specified'"
+        ctx["start_command"] = "python3 main.py"
+        ctx["migration_section"] = ""
         _copy_dbos_template(
             os.path.join(src_dir, "dbos-config.yaml.dbos"),
             os.path.join(dst_dir, "dbos-config.yaml"),