motia 0.5.11-beta.120-742949 → 0.5.11-beta.120-110250

package/dist/cjs/cli.js

@@ -156,14 +156,6 @@ generate
         stepFilePath: arg.dir,
     });
 });
-generate
-    .command('tutorial-flow')
-    .description('Download the tutorial flow into an existing motia project')
-    .action((0, config_utils_1.handler)(async (_, context) => {
-    const { createTutorialFlow } = require('./create/setup-tutorial-flow');
-    await createTutorialFlow({ context });
-    process.exit(0);
-}));
 const docker = commander_1.program.command('docker').description('Motia docker commands');
 docker
     .command('setup')

package/dist/cjs/cloud/build/builders/python/index.js

@@ -23,21 +23,12 @@ class PythonBuilder {
         const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
         // Get Python builder response
-        const { packages, local_files } = await this.getPythonBuilderData(step);
+        const { packages } = await this.getPythonBuilderData(step);
         // Add main file to archive
         if (!fs_1.default.existsSync(step.filePath)) {
             throw new Error(`Source file not found: ${step.filePath}`);
         }
         archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-        // Add local Python files to archive
-        if (local_files && local_files.length > 0) {
-            local_files.forEach((localFile) => {
-                const fullPath = path_1.default.join(this.builder.projectDir, localFile);
-                if (fs_1.default.existsSync(fullPath)) {
-                    archive.append(fs_1.default.createReadStream(fullPath), localFile);
-                }
-            });
-        }
         await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, packageName)));
         return normalizedEntrypointPath;
     }
@@ -51,7 +42,7 @@ class PythonBuilder {
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
             this.listener.onBuildStart(step);
             // Get Python builder response
-            const { packages, local_files } = await this.getPythonBuilderData(step);
+            const { packages } = await this.getPythonBuilderData(step);
             const stepArchiver = new archiver_1.Archiver(outfile);
             const stepPath = await this.buildStep(step, stepArchiver);
             // Add main file to archive
@@ -62,16 +53,6 @@ class PythonBuilder {
             // Add all imported files to archive
             this.listener.onBuildProgress(step, 'Adding imported files to archive...');
             const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-            // Add local Python files to archive
-            if (local_files && local_files.length > 0) {
-                local_files.forEach((localFile) => {
-                    const fullPath = path_1.default.join(this.builder.projectDir, localFile);
-                    if (fs_1.default.existsSync(fullPath)) {
-                        stepArchiver.append(fs_1.default.createReadStream(fullPath), localFile);
-                    }
-                });
-                this.listener.onBuildProgress(step, `Added ${local_files.length} local Python files to archive`);
-            }
             (0, include_static_files_1.includeStaticFiles)([step], this.builder, stepArchiver);
             if (packages.length > 0) {
                 await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(stepArchiver, sitePackagesDir, packageName)));

package/dist/cjs/cloud/build/builders/python/python-builder.py

@@ -82,23 +82,6 @@ def is_builtin_module(module_name: str) -> bool:
     """Check if a module is a Python built-in module."""
     if module_name in _builtin_modules_cache:
         return True
-    
-    # First check if it's a known built-in module name
-    builtin_modules = {
-        'os', 'sys', 'json', 'math', 'random', 'datetime', 'time', 'urllib', 'http', 
-        'pathlib', 're', 'collections', 'itertools', 'functools', 'operator', 'typing',
-        'io', 'csv', 'xml', 'html', 'email', 'base64', 'hashlib', 'hmac', 'uuid',
-        'pickle', 'sqlite3', 'logging', 'unittest', 'argparse', 'configparser',
-        'tempfile', 'shutil', 'glob', 'fnmatch', 'subprocess', 'threading', 'queue',
-        'multiprocessing', 'concurrent', 'asyncio', 'socket', 'ssl', 'gzip', 'zipfile',
-        'tarfile', 'zlib', 'bz2', 'lzma', 'struct', 'array', 'ctypes', 'mmap',
-        'weakref', 'gc', 'inspect', 'dis', 'ast', 'token', 'tokenize', 'keyword',
-        'builtins', '__main__', 'site', 'sysconfig', 'platform', 'warnings'
-    }
-    
-    if module_name in builtin_modules:
-        _builtin_modules_cache.add(module_name)
-        return True
         
     try:
         module = importlib.import_module(module_name)
@@ -117,8 +100,6 @@ def is_builtin_module(module_name: str) -> bool:
             _builtin_modules_cache.add(module_name)
         return is_builtin
     except ImportError:
-        # If we can't import it, assume it's not a built-in module
-        # This handles local modules that aren't in the current Python path
         return False
 
 def get_direct_imports(file_path: str) -> Set[str]:
@@ -146,101 +127,6 @@ def get_direct_imports(file_path: str) -> Set[str]:
     
     return direct_imports
 
-def get_all_python_files(project_root: str) -> List[str]:
-    """Get all Python files in the project."""
-    python_files = []
-    for root, dirs, files in os.walk(project_root):
-        # Skip common directories
-        dirs[:] = [d for d in dirs if not d.startswith('.') and d not in 
-                  {'__pycache__', 'node_modules', 'dist', 'build', 'venv'}]
-        
-        for file in files:
-            if file.endswith('.py') and not file.startswith('.'):
-                full_path = os.path.join(root, file)
-                relative_path = os.path.relpath(full_path, project_root)
-                python_files.append(relative_path)
-    
-    return python_files
-
-def get_imports_from_file(file_path: str) -> Set[str]:
-    """Get all import module names from a Python file."""
-    imports = set()
-    
-    try:
-        with open(file_path, 'r') as f:
-            content = f.read()
-        
-        tree = ast.parse(content)
-        for node in ast.walk(tree):
-            if isinstance(node, ast.Import):
-                for name in node.names:
-                    imports.add(name.name)
-            elif isinstance(node, ast.ImportFrom):
-                if node.module:
-                    imports.add(node.module)
-    except Exception as e:
-        print(f"Warning: Could not parse imports from {file_path}: {str(e)}")
-    
-    return imports
-
-def get_local_files_for_entry(entry_file: str) -> List[str]:
-    """Get local Python files that are imported by the entry file."""
-    # Find project root
-    project_root = os.path.dirname(entry_file)
-    while project_root != os.path.dirname(project_root):
-        if any(os.path.exists(os.path.join(project_root, f)) 
-               for f in ['package.json', 'requirements.txt']):
-            break
-        project_root = os.path.dirname(project_root)
-    
-    # Get all Python files in the project
-    all_python_files = get_all_python_files(project_root)
-    
-    # Get imports from the entry file
-    imports = get_imports_from_file(entry_file)
-    
-    # Check which imports match local Python files
-    local_files = []
-    for import_name in imports:
-        for py_file in all_python_files:
-            # Convert file path to module name (e.g., 'utils/example.py' -> 'utils.example')
-            module_name = py_file.replace(os.sep, '.').replace('.py', '')
-            if import_name == module_name:
-                local_files.append(py_file)
-    
-    return sorted(local_files)
-
-def trace_imports(entry_file: str) -> List[str]:
-    """Find all imported Python packages from entry file and its local imports."""
-    entry_file = os.path.abspath(entry_file)
-    
-    # Get local files that are imported
-    local_files = get_local_files_for_entry(entry_file)
-    
-    # Get project root
-    project_root = os.path.dirname(entry_file)
-    while project_root != os.path.dirname(project_root):
-        if any(os.path.exists(os.path.join(project_root, f)) 
-               for f in ['package.json', 'requirements.txt']):
-            break
-        project_root = os.path.dirname(project_root)
-    
-    # Get imports from entry file and local files
-    all_packages = set()
-    processed_packages = set()
-    files_to_process = [entry_file] + [os.path.join(project_root, f) for f in local_files]
-    
-    for python_file in files_to_process:
-        if os.path.exists(python_file):
-            direct_imports = get_direct_imports(python_file)
-            for package_name in direct_imports:
-                if is_valid_package_name(package_name) and not is_builtin_module(package_name):
-                    all_packages.add(package_name)
-                    # Get all dependencies including sub-dependencies
-                    all_packages.update(get_package_dependencies(package_name, processed_packages))
-    
-    return sorted(list(all_packages))
-
 @lru_cache(maxsize=1024)
 def is_optional_dependency(req: str) -> bool:
     """Check if a dependency is an optional dependency."""
@@ -289,6 +175,33 @@ def get_package_dependencies(package_name: str, processed: Set[str] = None) -> S
     
     return all_dependencies
 
+def trace_imports(entry_file: str) -> List[str]:
+    """Find all imported Python packages and files starting from an entry file."""
+    entry_file = os.path.abspath(entry_file)
+    module_dir = os.path.dirname(entry_file)
+    
+    if module_dir not in sys.path:
+        sys.path.insert(0, module_dir)
+    
+    # Get direct imports from the entry file
+    direct_imports = get_direct_imports(entry_file)
+    
+    # Initialize sets to track packages
+    all_packages = set()
+    processed_packages = set()
+    
+    # Process each direct import and its dependencies
+    for package_name in direct_imports:
+        if is_valid_package_name(package_name):
+            all_packages.add(package_name)
+            # Get all dependencies including sub-dependencies
+            all_packages.update(get_package_dependencies(package_name, processed_packages))
+    
+    # Filter out built-in packages
+    non_builtin_packages = {pkg for pkg in all_packages if not is_builtin_module(pkg)}
+    
+    return sorted(list(non_builtin_packages))
+
 def main() -> None:
     """Main entry point for the script."""
     if len(sys.argv) != 2:
@@ -298,13 +211,8 @@ def main() -> None:
     entry_file = sys.argv[1]
     try:
         packages = trace_imports(entry_file)
-        local_files = get_local_files_for_entry(entry_file)
-        
-
-        
         output = {
-            'packages': packages,
-            'local_files': local_files
+            'packages': packages
         }
         bytes_message = (json.dumps(output) + '\n').encode('utf-8')
         os.write(NODEIPCFD, bytes_message)

package/dist/cjs/create/templates/default/motia-workbench.json

@@ -1,28 +1,27 @@
 [
   {
-    "id": "default",
+    "id": "basic-tutorial",
     "config": {
-      "steps/00-noop.step.ts": {
-        "x": -507,
-        "y": 111,
+      "steps/basic-tutorial/03-state-audit-cron.step.ts": {
+        "x": -165,
+        "y": 217,
         "sourceHandlePosition": "right"
       },
-      "steps/01-api.step.ts": {
-        "x": -281,
-        "y": 94,
-        "sourceHandlePosition": "right",
+      "steps/basic-tutorial/02-process-food-order.step.ts": {
+        "x": 211,
+        "y": 17,
+        "sourceHandlePosition": "bottom",
         "targetHandlePosition": "left"
       },
-      "steps/02-test-state.step.ts": {
-        "x": 60,
-        "y": 36,
-        "sourceHandlePosition": "bottom",
+      "steps/basic-tutorial/01-api.step.ts": {
+        "x": -100,
+        "y": 3,
+        "sourceHandlePosition": "right",
         "targetHandlePosition": "left"
       },
-      "steps/03-check-state-change.step.ts": {
-        "x": 78,
-        "y": 199,
-        "targetHandlePosition": "top"
+      "steps/basic-tutorial/04-notification.step.ts": {
+        "x": 300,
+        "y": 264
       }
     }
   }

package/dist/cjs/create/templates/default/services/pet-store.ts.txt

@@ -0,0 +1,24 @@
+import { Order, Pet } from './types'
+
+export const petStoreService = {
+  createPet: async (pet: Omit<Pet, 'id'>): Promise<Pet> => {
+    const response = await fetch('https://petstore.swagger.io/v2/pet', {
+      method: 'POST',
+      body: JSON.stringify({
+        name: pet.name,
+        photoUrls: [pet.photoUrl],
+        status: 'available',
+      }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    return response.json()
+  },
+  createOrder: async (order: Omit<Order, 'id'>): Promise<Order> => {
+    const response = await fetch('https://petstore.swagger.io/v2/store/order', {
+      method: 'POST',
+      body: JSON.stringify(order),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    return response.json()
+  },
+}

package/dist/cjs/create/templates/default/services/types.ts.txt

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+export const petSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  photoUrl: z.string(),
+})
+
+export const orderStatusSchema = z.enum(['placed', 'approved', 'delivered'])
+
+export const orderSchema = z.object({
+  id: z.string(),
+  quantity: z.number(),
+  petId: z.number(),
+  shipDate: z.string(),
+  status: orderStatusSchema,
+})
+
+export type Pet = z.infer<typeof petSchema>
+export type Order = z.infer<typeof orderSchema>
+export type OrderStatus = z.infer<typeof orderStatusSchema>

package/dist/cjs/create/templates/default/steps/01-api.step.ts-features.json.txt

@@ -0,0 +1,67 @@
+[
+  {
+    "id": "step-configuration",
+    "title": "Step Configuration",
+    "description": "All steps should have a defined configuration, this is how you define the step's behavior and how it will be triggered.",
+    "lines": [
+      "6-30"
+    ]
+  },
+  {
+    "id": "api-configuration",
+    "title": "API Step",
+    "description": "Definition of an API endpoint",
+    "lines": [
+      "12-13"
+    ]
+  },
+  {
+    "id": "request-body",
+    "title": "Request body",
+    "description": "Definition of the expected request body. Motia will automatically generate types based on this schema.",
+    "lines": [
+      "14-25"
+    ]
+  },
+  {
+    "id": "response-payload",
+    "title": "Response Payload",
+    "description": "Definition of the expected response payload, Motia will generate the types automatically based on this schema. This is also important to create the Open API spec later.",
+    "lines": [
+      "26-28"
+    ]
+  },
+  {
+    "id": "event-driven-architecture",
+    "title": "Emits",
+    "description": "We can define the events that this step will emit, this is how we can trigger other Motia Steps.",
+    "lines": [
+      "29",
+      "39-46"
+    ]
+  },
+  {
+    "id": "handler",
+    "title": "Handler",
+    "description": "The handler is the function that will be executed when the step is triggered. This one receives the request body and emits events.",
+    "lines": [
+      "32-50"
+    ]
+  },
+  {
+    "id": "logger",
+    "title": "Logger",
+    "description": "The logger is a utility that allows you to log messages to the console. It is available in the handler function. We encourage you to use it instead of console.log. It will automatically be tied to the trace id of the request.",
+    "lines": [
+      "33"
+    ]
+  },
+  {
+    "id": "http-response",
+    "title": "HTTP Response",
+    "description": "The handler can return a response to the client. This is how we can return a response to the client. It must comply with the responseSchema defined in the step configuration.",
+    "lines": [
+      "49"
+    ]
+  }
+]

package/dist/cjs/create/templates/{basic-tutorial → default/steps}/01-api.step.ts.txt

@@ -1,6 +1,7 @@
 import { ApiRouteConfig, Handlers } from 'motia'
 import { z } from 'zod'
-import { petStoreService } from './services/pet-store'
+import { petStoreService } from '../services/pet-store'
+import { petSchema } from '../services/types'
 
 export const config: ApiRouteConfig = {
   type: 'api',
@@ -23,10 +24,7 @@ export const config: ApiRouteConfig = {
       .optional(),
   }),
   responseSchema: {
-    200: z.object({
-      message: z.string(),
-      traceId: z.string(),
-    }),
+    200: petSchema,
   },
   emits: ['process-food-order'],
 }
@@ -35,7 +33,6 @@ export const handler: Handlers['ApiTrigger'] = async (req, { logger, emit, trace
   logger.info('Step 01 – Processing API Step', { body: req.body })
 
   const { pet, foodOrder } = req.body
-
   const newPetRecord = await petStoreService.createPet(pet)
 
   if (foodOrder) {
@@ -43,16 +40,11 @@ export const handler: Handlers['ApiTrigger'] = async (req, { logger, emit, trace
       topic: 'process-food-order',
       data: {
         ...foodOrder,
+        email: 'test@test.com', // sample email
         petId: newPetRecord.id,
       },
     })
   }
 
-  return {
-    status: 200,
-    body: {
-      traceId,
-      message: 'Your pet has been registered and your order is being processed',
-    },
-  }
+  return { status: 200, body: newPetRecord }
 }

package/dist/cjs/create/templates/default/steps/02-process-food-order.step.ts-features.json.txt

@@ -0,0 +1,67 @@
+[
+  {
+    "id": "step-configuration",
+    "title": "Step Configuration",
+    "description": "All steps should have a defined configuration, this is how you define the step's behavior and how it will be triggered.",
+    "lines": [
+      "5-17"
+    ]
+  },
+  {
+    "id": "event-configuration",
+    "title": "Event Step",
+    "description": "Definition of an event step that subscribes to specific topics",
+    "lines": [
+      "6",
+      "10-11"
+    ]
+  },
+  {
+    "id": "input-schema",
+    "title": "Input Schema",
+    "description": "Definition of the expected input data structure from the subscribed topic. Motia will automatically generate types based on this schema.",
+    "lines": [
+      "12-16"
+    ]
+  },
+  {
+    "id": "event-emits",
+    "title": "Emits",
+    "description": "We can define the events that this step will emit, triggering other Motia Steps.",
+    "lines": [
+      "11"
+    ]
+  },
+  {
+    "id": "handler",
+    "title": "Handler",
+    "description": "The handler is the function that will be executed when the step receives an event from its subscribed topic. It processes the input data and can emit new events.",
+    "lines": [
+      "19-44"
+    ]
+  },
+  {
+    "id": "state",
+    "title": "State Management",
+    "description": "The handler demonstrates state management by storing order data that can be accessed by other steps.",
+    "lines": [
+      "28"
+    ]
+  },
+  {
+    "id": "event-emission",
+    "title": "Event Emission",
+    "description": "After processing the order, the handler emits a new event to notify other steps about the new order.",
+    "lines": [
+      "30-43"
+    ]
+  },
+  {
+    "id": "logger",
+    "title": "Logger",
+    "description": "The logger is a utility that allows you to log messages to the console. It is available in the handler function and automatically ties to the trace id of the request.",
+    "lines": [
+      "20"
+    ]
+  }
+]

package/dist/{esm/create/templates/basic-tutorial → cjs/create/templates/default/steps}/02-process-food-order.step.ts.txt

@@ -1,6 +1,6 @@
 import { EventConfig, Handlers } from 'motia'
 import { z } from 'zod'
-import { petStoreService } from './services/pet-store'
+import { petStoreService } from '../services/pet-store'
 
 export const config: EventConfig = {
   type: 'event',
@@ -8,9 +8,9 @@ export const config: EventConfig = {
   description: 'basic-tutorial event step, demonstrates how to consume an event from a topic and persist data in state',
   flows: ['basic-tutorial'],
   subscribes: ['process-food-order'],
-  emits: ['new-order-notification'],
+  emits: ['notification'],
   input: z.object({
-    id: z.string(),
+    email: z.string(),
     quantity: z.number(),
     petId: z.number(),
   }),
@@ -19,12 +19,26 @@ export const config: EventConfig = {
 export const handler: Handlers['ProcessFoodOrder'] = async (input, { traceId, logger, state, emit }) => {
   logger.info('Step 02 – Process food order', { input, traceId })
 
-  const order = await petStoreService.createOrder(input)
+  const order = await petStoreService.createOrder({
+    ...input,
+    shipDate: new Date().toISOString(),
+    status: 'placed',
+  })
 
-  await state.set<string>('orders', order.id, order)
+  await state.set('orders', order.id, order)
 
   await emit({
-    topic: 'new-order-notification',
-    data: { order_id: order.id },
+    topic: 'notification',
+    data: {
+      email: input.email,
+      templateId: 'new-order',
+      templateData: {
+        status: order.status,
+        shipDate: order.shipDate,
+        id: order.id,
+        petId: order.petId,
+        quantity: order.quantity,
+      },
+    },
   })
 }

package/dist/cjs/create/templates/default/steps/03-state-audit-cron.step.ts-features.json.txt

@@ -0,0 +1,26 @@
+[
+  {
+    "id": "step-configuration",
+    "title": "Step Configuration",
+    "description": "All steps should have a defined configuration, this is how you define the step's behavior and how it will be triggered.",
+    "lines": [
+      "3-10"
+    ]
+  },
+  {
+    "id": "cron-configuration",
+    "title": "Cron Configuration",
+    "description": "Cron steps require a specific configuration structure with the 'type' field set to 'cron' and a valid cron expression.",
+    "lines": [
+      "4-5"
+    ]
+  },
+  {
+    "id": "handler",
+    "title": "Cron Step Handler",
+    "description": "The Cron step handler only receives one argument.",
+    "lines": [
+      "21-51"
+    ]
+  }
+]

package/dist/cjs/create/templates/default/steps/03-state-audit-cron.step.ts.txt

@@ -0,0 +1,51 @@
+import { CronConfig, Handlers } from 'motia'
+
+export const config: CronConfig = {
+  type: 'cron',
+  cron: '*/5 * * * *', // run every 5 minutes
+  name: 'StateAuditJob',
+  description: 'Checks the state for orders that are not complete and have a ship date in the past',
+  emits: ['notification'],
+  flows: ['basic-tutorial'],
+}
+
+type Order = {
+  id: number
+  petId: number
+  quantity: number
+  shipDate: string
+  status: string
+  complete: boolean
+}
+
+export const handler: Handlers['StateAuditJob'] = async ({ logger, state, emit }) => {
+  const stateValue = await state.getGroup<Order>('orders')
+
+  for (const item of stateValue) {
+    // check if current date is after item.shipDate
+    const currentDate = new Date()
+    const shipDate = new Date(item.shipDate)
+
+    if (!item.complete && currentDate > shipDate) {
+      logger.warn('Order is not complete and ship date is past', {
+        orderId: item.id,
+        shipDate: item.shipDate,
+        complete: item.complete,
+      })
+
+      await emit({
+        topic: 'notification',
+        data: {
+          email: 'test@test.com',
+          templateId: 'order-audit-warning',
+          templateData: {
+            orderId: item.id,
+            status: item.status,
+            shipDate: item.shipDate,
+            message: 'Order is not complete and ship date is past',
+          },
+        },
+      })
+    }
+  }
+}