motia 0.5.12-beta.121 → 0.6.0-beta.122

package/dist/cjs/cli.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-require-imports */
 const commander_1 = require("commander");
 require("./cloud");
 const version_1 = require("./version");
 const config_utils_1 = require("./cloud/config-utils");
+const inquirer_1 = __importDefault(require("inquirer"));
 const defaultPort = 3000;
 const defaultHost = '0.0.0.0';
 require('dotenv/config');
@@ -28,14 +32,23 @@ commander_1.program
     .option('-c, --cursor', 'Copy .cursor folder from template')
     .option('-i, --interactive', 'Use interactive prompts to create project')
     .option('-y, --skip-confirmation', 'Skip confirmation prompt')
+    .option('-d, --skip-tutorial', 'Skip the motia tutorial', false)
     .action((0, config_utils_1.handler)(async (arg, context) => {
     if (arg.name || arg.template || arg.cursor) {
         const { create } = require('./create');
+        const disableTutorial = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'disableTutorial',
+            message: 'Do you wish to disable the motia tutorial?',
+            default: arg.skipTutorial,
+            when: () => arg.skipTutorial === false,
+        });
         await create({
             projectName: arg.name ?? '.',
             template: arg.template ?? 'default',
             cursorEnabled: arg.cursor,
             context,
+            skipTutorialTemplates: disableTutorial.disableTutorial,
         });
     }
     else {

package/dist/cjs/create/index.d.ts

@@ -4,6 +4,7 @@ type Args = {
     template?: string;
     cursorEnabled?: boolean;
     context: CliContext;
+    skipTutorialTemplates?: boolean;
 };
 export declare const create: ({ projectName, template, cursorEnabled, context }: Args) => Promise<void>;
 export {};

package/dist/cjs/create/index.js

@@ -6,35 +6,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const templates_1 = require("./templates");
 const execute_command_1 = require("../utils/execute-command");
 const install_1 = require("../install");
 const generate_types_1 = require("../generate-types");
 const version_1 = require("../version");
+const setup_template_1 = require("./setup-template");
+const utils_1 = require("./utils");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
     transpileOnly: true,
     compilerOptions: { module: 'commonjs' },
 });
-const checkIfFileExists = (dir, fileName) => {
-    return fs_1.default.existsSync(path_1.default.join(dir, fileName));
-};
-const checkIfDirectoryExists = (dir) => {
-    try {
-        return fs_1.default.statSync(dir).isDirectory();
-    }
-    catch {
-        return false;
-    }
-};
 const getPackageManager = (dir) => {
-    if (checkIfFileExists(dir, 'yarn.lock')) {
+    if ((0, utils_1.checkIfFileExists)(dir, 'yarn.lock')) {
         return 'yarn';
     }
-    else if (checkIfFileExists(dir, 'pnpm-lock.yaml')) {
+    else if ((0, utils_1.checkIfFileExists)(dir, 'pnpm-lock.yaml')) {
         return 'pnpm';
     }
-    else if (checkIfFileExists(dir, 'package-lock.json')) {
+    else if ((0, utils_1.checkIfFileExists)(dir, 'package-lock.json')) {
         return 'npm';
     }
     else {
@@ -97,14 +87,14 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         '\n\n');
     const isCurrentDir = projectName === '.' || projectName === './' || projectName === '.\\';
     const rootDir = isCurrentDir ? process.cwd() : path_1.default.join(process.cwd(), projectName);
-    if (!isCurrentDir && !checkIfDirectoryExists(rootDir)) {
+    if (!isCurrentDir && !(0, utils_1.checkIfDirectoryExists)(rootDir)) {
         fs_1.default.mkdirSync(path_1.default.join(rootDir));
         context.log('directory-created', (message) => message.tag('success').append('Directory created ').append(projectName, 'gray'));
     }
     else {
         context.log('directory-using', (message) => message.tag('info').append('Using current directory'));
     }
-    if (!checkIfFileExists(rootDir, 'package.json')) {
+    if (!(0, utils_1.checkIfFileExists)(rootDir, 'package.json')) {
         const packageJsonContent = {
             name: projectName,
             description: '',
@@ -144,7 +134,7 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
             .append('command to')
             .append('package.json', 'gray'));
     }
-    if (!checkIfFileExists(rootDir, 'tsconfig.json')) {
+    if (!(0, utils_1.checkIfFileExists)(rootDir, 'tsconfig.json')) {
         const tsconfigContent = {
             compilerOptions: {
                 target: 'ES2020',
@@ -167,7 +157,7 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.writeFileSync(path_1.default.join(rootDir, 'tsconfig.json'), JSON.stringify(tsconfigContent, null, 2));
         context.log('tsconfig-json-created', (message) => message.tag('success').append('File').append('tsconfig.json', 'cyan').append('has been created.'));
     }
-    if (!checkIfFileExists(rootDir, '.gitignore')) {
+    if (!(0, utils_1.checkIfFileExists)(rootDir, '.gitignore')) {
         const gitignoreContent = [
             'node_modules',
             'python_modules',
@@ -183,31 +173,15 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
     }
     const cursorTemplateDir = path_1.default.join(__dirname, '../../dot-files/.cursor');
     const cursorTargetDir = path_1.default.join(rootDir, '.cursor');
-    if (cursorEnabled && !checkIfDirectoryExists(cursorTargetDir)) {
+    if (cursorEnabled && !(0, utils_1.checkIfDirectoryExists)(cursorTargetDir)) {
         fs_1.default.cpSync(cursorTemplateDir, cursorTargetDir, { recursive: true });
         context.log('cursor-folder-created', (message) => message.tag('success').append('Folder').append('.cursor', 'cyan').append('has been created.'));
     }
-    const stepsDir = path_1.default.join(rootDir, 'steps');
-    if (!checkIfDirectoryExists(stepsDir)) {
-        fs_1.default.mkdirSync(stepsDir);
-        context.log('steps-directory-created', (message) => message.tag('success').append('Folder').append('steps', 'cyan').append('has been created.'));
-    }
-    if (!template || !(template in templates_1.templates)) {
-        context.log('template-not-found', (message) => message.tag('failed').append(`Template ${template} not found, please use one of the following:`));
-        context.log('available-templates', (message) => message.tag('info').append(`Available templates: \n\n ${Object.keys(templates_1.templates).join('\n')}`));
-        return;
+    if (template) {
+        await (0, setup_template_1.setupTemplate)(template, rootDir, context);
     }
-    await templates_1.templates[template](rootDir, context);
     const packageManager = await installNodeDependencies(rootDir, context);
     if (template === 'python') {
-        if (!checkIfFileExists(rootDir, 'requirements.txt')) {
-            const requirementsContent = [
-            // TODO: motia PyPi package
-            // Add other Python dependencies as needed
-            ].join('\n');
-            fs_1.default.writeFileSync(path_1.default.join(rootDir, 'requirements.txt'), requirementsContent);
-            context.log('requirements-txt-created', (message) => message.tag('success').append('File').append('requirements.txt', 'gray').append('has been created.'));
-        }
         await (0, install_1.pythonInstall)({ baseDir: rootDir });
     }
     await (0, generate_types_1.generateTypes)(rootDir);

package/dist/cjs/create/interactive.js

@@ -8,7 +8,7 @@ const inquirer_1 = __importDefault(require("inquirer"));
 const colors_1 = __importDefault(require("colors"));
 const index_1 = require("./index");
 const choices = {
-    default: 'Base (TypeScript)',
+    typescript: 'Base (TypeScript)',
     python: 'Base (Python)',
 };
 const createInteractive = async (_args, context) => {

package/dist/cjs/create/setup-template.d.ts

@@ -0,0 +1,2 @@
+import { CliContext } from '@/cloud/config-utils';
+export declare const setupTemplate: (template: string, rootDir: string, context: CliContext) => Promise<void>;

package/dist/cjs/create/setup-template.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTemplate = void 0;
+const templates_1 = require("./templates");
+const setupTemplate = async (template, rootDir, context) => {
+    if (!template || !(template in templates_1.templates)) {
+        context.log('template-not-found', (message) => message.tag('failed').append(`Template ${template} not found, please use one of the following:`));
+        context.log('available-templates', (message) => message.tag('info').append(`Available templates: \n\n ${Object.keys(templates_1.templates).join('\n')}`));
+        return;
+    }
+    await templates_1.templates[template](rootDir, context);
+};
+exports.setupTemplate = setupTemplate;

package/dist/cjs/create/templates/generate.d.ts

@@ -1,3 +1,3 @@
 import { CliContext } from '../../cloud/config-utils';
 export type Generator = (rootDir: string, context: CliContext) => Promise<void>;
-export declare const generateTemplateSteps: (templateDir: string) => Generator;
+export declare const generateTemplateSteps: (templateFolder: string) => Generator;

package/dist/cjs/create/templates/generate.js

@@ -37,20 +37,43 @@ exports.generateTemplateSteps = void 0;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const glob_1 = require("glob");
-const generateTemplateSteps = (templateDir) => {
+const generateTemplateSteps = (templateFolder) => {
     return async (rootDir, context) => {
-        const templatePath = path.join(__dirname, templateDir);
+        const templatePath = path.join(__dirname, templateFolder);
         const files = (0, glob_1.globSync)('**/*', { absolute: false, cwd: templatePath });
         try {
             for (const fileName of files) {
                 const filePath = path.join(templatePath, fileName);
+                const targetFilePath = path.join(rootDir, fileName);
+                const targetDir = path.dirname(targetFilePath);
+                try {
+                    // Check if it's a directory in the template
+                    (0, fs_1.statSync)(targetDir);
+                }
+                catch {
+                    (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+                }
                 if ((0, fs_1.statSync)(filePath).isDirectory()) {
-                    // ignore folders
+                    const folderPath = path.basename(filePath);
+                    (0, fs_1.mkdirSync)(path.join(rootDir, folderPath), { recursive: true });
                     continue;
                 }
-                const sanitizedFileName = fileName.replace('.txt', '');
+                const sanitizedFileName = fileName === 'requirements.txt' ? fileName : fileName.replace('.txt', '');
+                const isWorkbenchConfig = fileName.match('motia-workbench.json');
                 const generateFilePath = path.join(rootDir, sanitizedFileName);
-                const content = await fs_1.promises.readFile(filePath, 'utf8');
+                let content = await fs_1.promises.readFile(filePath, 'utf8');
+                // Make sure statSync doesn't break the execution if the file doesn't exist
+                try {
+                    if (isWorkbenchConfig && (0, fs_1.statSync)(generateFilePath).isFile()) {
+                        const existingWorkbenchConfig = await fs_1.promises.readFile(generateFilePath, 'utf8');
+                        const workbenchContent = JSON.parse(content);
+                        content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2);
+                        context.log('workbench-config-updated', (message) => message.tag('success').append('Workbench config').append('has been updated.'));
+                    }
+                }
+                catch {
+                    void 0;
+                }
                 await fs_1.promises.writeFile(generateFilePath, content, 'utf8');
                 context.log(sanitizedFileName, (message) => {
                     message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.');

package/dist/cjs/create/templates/generate.ts

@@ -1,27 +1,54 @@
-import { promises as fs, statSync } from 'fs'
+import { promises as fs, statSync, mkdirSync } from 'fs'
 import * as path from 'path'
 import { globSync } from 'glob'
 import { CliContext } from '../../cloud/config-utils'
 
 export type Generator = (rootDir: string, context: CliContext) => Promise<void>
 
-export const generateTemplateSteps = (templateDir: string): Generator => {
+export const generateTemplateSteps = (templateFolder: string): Generator => {
   return async (rootDir: string, context: CliContext): Promise<void> => {
-    const templatePath = path.join(__dirname, templateDir)
+    const templatePath = path.join(__dirname, templateFolder)
     const files = globSync('**/*', { absolute: false, cwd: templatePath })
 
     try {
       for (const fileName of files) {
         const filePath = path.join(templatePath, fileName)
+        const targetFilePath = path.join(rootDir, fileName)
+        const targetDir = path.dirname(targetFilePath)
+
+        try {
+          // Check if it's a directory in the template
+          statSync(targetDir)
+        } catch {
+          mkdirSync(targetDir, { recursive: true })
+        }
 
         if (statSync(filePath).isDirectory()) {
-          // ignore folders
+          const folderPath = path.basename(filePath)
+          mkdirSync(path.join(rootDir, folderPath), { recursive: true })
           continue
         }
 
-        const sanitizedFileName = fileName.replace('.txt', '')
+        const sanitizedFileName = fileName === 'requirements.txt' ? fileName : fileName.replace('.txt', '')
+        const isWorkbenchConfig = fileName.match('motia-workbench.json')
         const generateFilePath = path.join(rootDir, sanitizedFileName)
-        const content = await fs.readFile(filePath, 'utf8')
+        let content = await fs.readFile(filePath, 'utf8')
+
+        // Make sure statSync doesn't break the execution if the file doesn't exist
+        try {
+          if (isWorkbenchConfig && statSync(generateFilePath).isFile()) {
+            const existingWorkbenchConfig = await fs.readFile(generateFilePath, 'utf8')
+            const workbenchContent = JSON.parse(content)
+
+            content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2)
+
+            context.log('workbench-config-updated', (message) =>
+              message.tag('success').append('Workbench config').append('has been updated.'),
+            )
+          }
+        } catch {
+          void 0
+        }
 
         await fs.writeFile(generateFilePath, content, 'utf8')
         context.log(sanitizedFileName, (message) => {

package/dist/cjs/create/templates/index.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.templates = void 0;
 const generate_1 = require("./generate");
 exports.templates = {
-    default: (0, generate_1.generateTemplateSteps)('default'),
+    typescript: (0, generate_1.generateTemplateSteps)('typescript'),
     python: (0, generate_1.generateTemplateSteps)('python'),
 };

package/dist/cjs/create/templates/index.ts

@@ -1,6 +1,6 @@
 import { generateTemplateSteps, Generator } from './generate'
 
 export const templates: Record<string, Generator> = {
-  default: generateTemplateSteps('default'),
+  typescript: generateTemplateSteps('typescript'),
   python: generateTemplateSteps('python'),
 }

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

@@ -1,28 +1,26 @@
 [
   {
-    "id": "default",
+    "id": "python-tutorial",
     "config": {
-      "steps/00_noop_step.py": {
-        "x": -507,
-        "y": 111,
+      "steps/state_audit_cron_step.py": {
+        "x": -38,
+        "y": 683,
         "sourceHandlePosition": "right"
       },
-      "steps/01_api_step.py": {
-        "x": -281,
-        "y": 94,
-        "sourceHandlePosition": "right",
+      "steps/process_food_order_step.py": {
+        "x": 384,
+        "y": 476,
         "targetHandlePosition": "left"
       },
-      "steps/02_test_state_step.py": {
-        "x": 60,
-        "y": 36,
-        "sourceHandlePosition": "bottom",
+      "steps/notification_step.py": {
+        "x": 601,
+        "y": 724,
         "targetHandlePosition": "left"
       },
-      "steps/03_check_state_change_step.py": {
-        "x": 78,
-        "y": 199,
-        "targetHandlePosition": "top"
+      "steps/api_step.py": {
+        "x": 15,
+        "y": 461,
+        "sourceHandlePosition": "right"
       }
     }
   }

package/dist/cjs/create/templates/python/requirements.txt

@@ -0,0 +1,2 @@
+pydantic>=2.6.1
+httpx>=0.28.1

package/dist/cjs/create/templates/python/steps/api_step.py-features.json.txt

@@ -0,0 +1,69 @@
+[
+  {
+    "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": [
+      "23-24"
+    ]
+  },
+  {
+    "id": "request-body",
+    "title": "Request body",
+    "description": "Definition of the expected request body. Motia will automatically generate types based on this schema.",
+    "lines": [
+      "6-16",
+      "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": [
+      "4",
+      "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",
+      "42-50"
+    ]
+  },
+  {
+    "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-52"
+    ]
+  },
+  {
+    "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": [
+      "34"
+    ]
+  },
+  {
+    "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": [
+      "52"
+    ]
+  }
+]

package/dist/cjs/create/templates/python/steps/api_step.py.txt

@@ -0,0 +1,52 @@
+from pydantic import BaseModel
+from typing import Optional
+from .services.pet_store import pet_store_service
+from .services.types import Pet
+
+class PetRequest(BaseModel):
+    name: str
+    photo_url: str
+
+class FoodOrder(BaseModel):
+    id: str
+    quantity: int
+
+class RequestBody(BaseModel):
+    pet: PetRequest
+    food_order: Optional[FoodOrder] = None
+
+config = {
+    "type": "api",
+    "name": "PythonApiTrigger",
+    "description": "basic-tutorial api trigger",
+    "flows": ["python-tutorial"],
+    "method": "POST",
+    "path": "/python-basic-tutorial",
+    "bodySchema": RequestBody.model_json_schema(),
+    "responseSchema": {
+        200: Pet.model_json_schema(),
+    },
+    "emits": ["python-process-food-order"],
+}
+
+async def handler(req, context):
+    body = req.get("body", {})
+    context.logger.info("Step 01 – Processing API Step", {"body": body})
+
+    pet = body.get("pet", {})
+    food_order = body.get("food_order", {})
+    
+    new_pet_record = await pet_store_service.create_pet(pet)
+
+    if food_order:
+        await context.emit({
+            "topic": "python-process-food-order",
+            "data": {
+                "id": food_order.get("id"),
+                "quantity": food_order.get("quantity"),
+                "email": "test@test.com",  # sample email
+                "pet_id": new_pet_record.get("id"),
+            },
+        })
+
+    return {"status": 200, "body": new_pet_record}

package/dist/cjs/create/templates/python/steps/notification_step.py.txt

@@ -0,0 +1,40 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+import re
+
+class InputSchema(BaseModel):
+    template_id: str
+    email: str
+    template_data: Dict[str, Any]
+
+config = {
+    "type": "event",
+    "name": "PythonNotification",
+    "description": "Checks a state change",
+    "flows": ["python-tutorial"],
+    "subscribes": ["python-notification"],
+    "emits": [],
+    "input": InputSchema.model_json_schema(),
+}
+
+async def handler(input_data, context):
+    email = input_data.get("email")
+    template_id = input_data.get("template_id")
+    template_data = input_data.get("template_data")
+    
+    redacted_email = re.sub(r'(?<=.{2}).(?=.*@)', '*', email)
+
+    context.logger.info("Processing Notification", {
+        "template_id": template_id,
+        "template_data": template_data,
+        "email": redacted_email,
+    })
+
+    # This represents a call to some sort of
+    # notification service to indicate that a
+    # new order has been placed
+    context.logger.info("New notification sent", {
+        "template_id": template_id,
+        "email": redacted_email,
+        "template_data": template_data,
+    })

package/dist/cjs/create/templates/python/steps/process_food_order_step.py-features.json.txt

@@ -0,0 +1,68 @@
+[
+  {
+    "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-19"
+    ]
+  },
+  {
+    "id": "event-configuration",
+    "title": "Event Step",
+    "description": "Definition of an event step that subscribes to specific topics",
+    "lines": [
+      "12",
+      "15-16"
+    ]
+  },
+  {
+    "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": [
+      "5-9",
+      "17"
+    ]
+  },
+  {
+    "id": "event-emits",
+    "title": "Emits",
+    "description": "We can define the events that this step will emit, triggering other Motia Steps.",
+    "lines": [
+      "17"
+    ]
+  },
+  {
+    "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": [
+      "21-50"
+    ]
+  },
+  {
+    "id": "state",
+    "title": "State Management",
+    "description": "The handler demonstrates state management by storing order data that can be accessed by other steps.",
+    "lines": [
+      "35"
+    ]
+  },
+  {
+    "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": [
+      "37-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 and automatically ties to the trace id of the request.",
+    "lines": [
+      "22"
+    ]
+  }
+]

package/dist/cjs/create/templates/python/steps/process_food_order_step.py.txt

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from datetime import datetime
+from .services.pet_store import pet_store_service
+
+class InputSchema(BaseModel):
+    id: str
+    email: str
+    quantity: int
+    pet_id: int
+
+config = {
+    "type": "event",
+    "name": "PythonProcessFoodOrder",
+    "description": "basic-tutorial event step, demonstrates how to consume an event from a topic and persist data in state",
+    "flows": ["python-tutorial"],
+    "subscribes": ["python-process-food-order"],
+    "emits": ["python-notification"],
+    "input": InputSchema.model_json_schema(),
+}
+
+async def handler(input_data, context):
+    context.logger.info("Step 02 – Process food order", {"input": input_data})
+
+    order = await pet_store_service.create_order({
+        "id": input_data.get("id"),
+        "quantity": input_data.get("quantity"),
+        "pet_id": input_data.get("pet_id"),
+        "email": input_data.get("email"),
+        "ship_date": datetime.now().isoformat(),
+        "status": "placed",
+    })
+
+    context.logger.info("Order created", {"order": order})
+
+    await context.state.set("orders_python", order.get("id"), order)
+
+    await context.emit({
+        "topic": "python-notification",
+        "data": {
+            "email": input_data["email"],
+            "template_id": "new-order",
+            "template_data": {
+                "status": order.get("status"),
+                "ship_date": order.get("shipDate"),
+                "id": order.get("id"),
+                "pet_id": order.get("petId"),
+                "quantity": order.get("quantity"),
+            },
+        },
+    })