Use a workflow-backed operation in the no-definition sample

Author: dandavison

hello_nexus/without_service_definition/app.py

@@ -3,32 +3,59 @@
 is calling the nexus service, without specifying a separate service definition.
 """
 
+from __future__ import annotations
+
 import asyncio
 import uuid
 from typing import Optional
 
+import temporalio.nexus.handler
 from nexusrpc.handler import (
     StartOperationContext,
     service_handler,
-    sync_operation_handler,
 )
 from temporalio import workflow
-from temporalio.client import Client
+from temporalio.client import Client, WorkflowHandle
+from temporalio.nexus.handler import workflow_run_operation_handler
 from temporalio.worker import UnsandboxedWorkflowRunner, Worker
 from temporalio.workflow import NexusClient
 
 NAMESPACE = "my-namespace"
 TASK_QUEUE = "my-task-queue"
 NEXUS_ENDPOINT = "my-nexus-endpoint"
 
+#
+# Handler
+#
+
+
+@workflow.defn
+class HandlerWorkflow:
+    @workflow.run
+    async def run(self, message: str) -> str:
+        return f"Hello {message} from workflow run operation!"
+
 
 # Here we define a nexus service by providing a service handler implementation without a
 # service contract.
 @service_handler
 class MyNexusServiceHandler:
-    @sync_operation_handler
-    async def my_sync_operation(self, ctx: StartOperationContext, name: str) -> str:
-        return f"Hello {name} from sync operation!"
+    # The nexus service has one operation. When using the workflow_run_operation_handler
+    # decorator, your start method must return a WorkflowHandle directly, using the
+    # temporalio.nexus.handler.start_workflow helper. (Temporal server takes care of
+    # delivering the workflow result to the caller, using the Nexus RPC callback mechanism).
+    @workflow_run_operation_handler
+    async def my_workflow_run_operation(
+        self, ctx: StartOperationContext, name: str
+    ) -> WorkflowHandle[HandlerWorkflow, str]:
+        return await temporalio.nexus.handler.start_workflow(
+            ctx, HandlerWorkflow.run, name, id=str(uuid.uuid4())
+        )
+
+
+#
+# Caller
+#
 
 
 @workflow.defn
@@ -39,11 +66,11 @@ async def run(self, message: str) -> str:
         # operation.
         #
         # Normally, the first argument to both these calls would reference a service
-        # contract class, but it can also reference your service handler class, as here.
+        # contract class, but they can also reference your service handler class, as here.
 
         nexus_client = NexusClient(MyNexusServiceHandler, endpoint=NEXUS_ENDPOINT)
         return await nexus_client.execute_operation(
-            MyNexusServiceHandler.my_sync_operation, message
+            MyNexusServiceHandler.my_workflow_run_operation, message
         )
 
 
@@ -54,7 +81,7 @@ async def execute_caller_workflow(client: Optional[Client] = None) -> str:
     async with Worker(
         client,
         task_queue=TASK_QUEUE,
-        workflows=[CallerWorkflow],
+        workflows=[CallerWorkflow, HandlerWorkflow],
         nexus_services=[MyNexusServiceHandler()],
         # TODO(dan): isinstance(op, nexusrpc.contract.Operation) is failing under the
         # sandbox in temporalio/worker/_interceptor.py