motia 0.0.16 → 0.0.18

package/dist/src/cli.js

@@ -7,11 +7,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
 const defaultPort = 3000;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 require('dotenv/config');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
     transpileOnly: true,
     compilerOptions: { module: 'commonjs' },
 });
+commander_1.program
+    .command('create')
+    .description('Create a new motia project')
+    .option('-n, --name <project name>', 'The name for your project, used to create a directory, use ./ or . to create it under the existing directory')
+    .option('-t, --template <template name>', 'The motia template name to use for your project')
+    .action(async (arg) => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { create } = require('./create');
+    await create({
+        projectName: arg.project ?? '.',
+        template: arg.template ?? undefined,
+    });
+});
+commander_1.program
+    .command('templates')
+    .description('Prints the list of available templates')
+    .action(async () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { templates } = require('./src/create/templates');
+    console.log(`📝 Available templates: \n\n ${Object.keys(templates).join('\n')}`);
+});
 commander_1.program
     .command('dev')
     .description('Start the development server')
@@ -23,7 +46,7 @@ commander_1.program
         process.env.LOG_LEVEL = 'debug';
     }
     const port = arg.port ? parseInt(arg.port) : defaultPort;
-    const { dev } = require('./dev');
+    const { dev } = require('./dev'); // eslint-disable-line @typescript-eslint/no-require-imports
     await dev(port);
 });
 commander_1.program
@@ -31,14 +54,44 @@ commander_1.program
     .description('Get the generated config for your project')
     .option('-o, --output <port>', 'Path to write the generated config')
     .action(async (arg) => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { generateLockedData } = require('./src/generate/locked-data');
     const lockedData = await generateLockedData(path_1.default.join(process.cwd()));
     if (arg.output) {
-        const fs = require('fs');
+        const fs = require('fs'); // eslint-disable-line @typescript-eslint/no-require-imports
         fs.writeFileSync(path_1.default.join(arg.output, '.motia.generated.json'), JSON.stringify(lockedData, null, 2));
         console.log(`📄 Wrote locked data to ${arg.output}`);
         return;
     }
     console.log(JSON.stringify(lockedData, null, 2));
 });
+commander_1.program
+    .command('emit')
+    .description('Emit an event to the Motia server')
+    .requiredOption('--topic <topic>', 'Event topic/type to emit')
+    .requiredOption('--message <message>', 'Event payload as JSON string')
+    .option('-p, --port <number>', 'Port number (default: 3000)')
+    .action(async (options) => {
+    const port = options.port || 3000;
+    const url = `http://localhost:${port}/emit`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                type: options.topic,
+                data: JSON.parse(options.message),
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const result = await response.json();
+        console.log('Event emitted successfully:', result);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+});
 commander_1.program.parse(process.argv);

package/dist/src/create/index.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const templates_1 = require("./templates");
+const figlet_1 = __importDefault(require("figlet"));
+// 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')) {
+        return 'yarn';
+    }
+    else if (checkIfFileExists(dir, 'pnpm-lock.yaml')) {
+        return 'pnpm';
+    }
+    else if (checkIfFileExists(dir, 'package-lock.json')) {
+        return 'npm';
+    }
+    else {
+        return 'unknown';
+    }
+};
+const executeCommand = async (command, rootDir) => {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(command, { cwd: rootDir }, (error, stdout, stderr) => {
+            if (error) {
+                console.error(`exec error: ${error}`);
+                reject(error);
+                return;
+            }
+            if (stdout)
+                console.log(stdout.toString());
+            if (stderr)
+                console.error(stderr.toString());
+            resolve(stdout);
+        });
+    });
+};
+const installRequiredDependencies = async (packageManager, rootDir) => {
+    console.log('📦 Installing dependencies...');
+    const installCommand = {
+        npm: 'npm install',
+        yarn: 'yarn add',
+        pnpm: 'pnpm add',
+    }[packageManager];
+    const dependencies = ['@motiadev/core', 'motia', '@motiadev/workbench', 'zod'].join(' ');
+    const devDependencies = ['ts-node@^10.9.2', 'typescript@^5.7.3'].join(' ');
+    try {
+        await executeCommand(`${installCommand} ${dependencies}`, rootDir);
+        await executeCommand(`${installCommand} -D ${devDependencies}`, rootDir);
+        console.log('✅ Dependencies installed');
+    }
+    catch (error) {
+        console.error('❌ Failed to install dependencies:', error);
+    }
+};
+const preparePackageManager = async (rootDir) => {
+    let packageManager = 'pnpm';
+    const detectedPackageManager = getPackageManager(rootDir);
+    if (detectedPackageManager !== 'unknown') {
+        console.log(`📦 Detected package manager: ${packageManager}`);
+        packageManager = detectedPackageManager;
+    }
+    else {
+        console.log(`📦 Using default package manager: ${packageManager}`);
+        const pnpmCheck = await executeCommand('pnpm --version', rootDir).catch(() => null);
+        if (!pnpmCheck) {
+            console.log('📦 pnpm is not installed. Installing pnpm...');
+            await executeCommand('npm install -g pnpm', rootDir);
+            console.log('✅ pnpm installed globally');
+        }
+    }
+    return packageManager;
+};
+const wrapUpSetup = async (rootDir) => {
+    const packageManager = await preparePackageManager(rootDir);
+    await installRequiredDependencies(packageManager, rootDir).catch((error) => {
+        console.log('❌ Failed to install dependencies');
+        console.error(error);
+    });
+    console.log(`\n\nTo start the development server, run:\n\n${packageManager} run dev\n\n`);
+    console.log('🚀 Project setup completed, happy coding!');
+};
+const create = async ({ projectName, template }) => {
+    console.log('\n\n' +
+        figlet_1.default.textSync('MOTIA', {
+            font: 'Larry 3D',
+            horizontalLayout: 'default',
+            verticalLayout: 'default',
+            width: 80,
+            whitespaceBreak: true,
+        }) +
+        '\n\n');
+    const isCurrentDir = !!projectName.match(/\.\/?/);
+    const rootDir = isCurrentDir ? process.cwd() : path_1.default.join(process.cwd(), projectName);
+    console.log(`🛠️ Welcome to motia! Let's get you setup.`);
+    if (!isCurrentDir && !checkIfDirectoryExists(rootDir)) {
+        fs_1.default.mkdirSync(path_1.default.join(rootDir));
+        console.log(`✅ ${projectName} directory created`);
+    }
+    else {
+        console.log(`📁 Using current directory`);
+    }
+    if (!checkIfFileExists(rootDir, 'package.json')) {
+        const packageJsonContent = {
+            name: 'my-motia-project',
+            description: '',
+            scripts: {
+                dev: 'motia dev',
+                'dev:debug': 'motia dev --debug',
+                'generate:config': 'motia get-config --output ./',
+            },
+            keywords: ['motia'],
+        };
+        fs_1.default.writeFileSync(path_1.default.join(rootDir, 'package.json'), JSON.stringify(packageJsonContent, null, 2));
+        console.log('✅ package.json created');
+    }
+    if (!checkIfFileExists(rootDir, 'tsconfig.json')) {
+        const tsconfigContent = {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'ESNext',
+                moduleResolution: 'Node',
+                esModuleInterop: true,
+                strict: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                resolveJsonModule: true,
+                allowJs: true,
+                outDir: 'dist',
+                rootDir: '.',
+                baseUrl: '.',
+                jsx: 'react-jsx',
+            },
+            include: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+            exclude: ['node_modules', 'dist', 'tests'],
+        };
+        fs_1.default.writeFileSync(path_1.default.join(rootDir, 'tsconfig.json'), JSON.stringify(tsconfigContent, null, 2));
+        console.log('✅ tsconfig.json created');
+    }
+    const stepsDir = path_1.default.join(rootDir, 'steps');
+    if (!checkIfDirectoryExists(stepsDir)) {
+        fs_1.default.mkdirSync(stepsDir);
+        console.log('✅ steps directory created');
+    }
+    if (!template) {
+        await wrapUpSetup(rootDir);
+        return;
+    }
+    if (template && !(template in templates_1.templates)) {
+        console.error(`❌ Template ${template} not found, please use one of the following:`);
+        console.log(`📝 Available templates: \n\n ${Object.keys(templates_1.templates).join('\n')}`);
+        await wrapUpSetup(rootDir);
+        return;
+    }
+    await templates_1.templates[template](stepsDir);
+    await wrapUpSetup(rootDir);
+};
+exports.create = create;

package/dist/src/create/templates/default/generate.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultTemplateSteps = exports.generateStepFiles = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const generateStepFiles = async (flowDir, files) => {
+    try {
+        for (const [fileName, content] of Object.entries(files)) {
+            const filePath = path.join(flowDir, fileName);
+            await fs_1.promises.writeFile(filePath, content, 'utf8');
+            console.log(`Step ${filePath} has been created.`);
+        }
+    }
+    catch (error) {
+        console.error('Error generating template files:', error);
+    }
+};
+exports.generateStepFiles = generateStepFiles;
+const generateDefaultTemplateSteps = async (flowDir) => {
+    const stepFiles = {
+        'one.step.ts': await fs_1.promises.readFile(path.join(__dirname, 'steps', 'one.step.txt'), 'utf8'),
+        'two.step.ts': await fs_1.promises.readFile(path.join(__dirname, 'steps', 'two.step.txt'), 'utf8'),
+        'api.step.ts': await fs_1.promises.readFile(path.join(__dirname, 'steps', 'api.step.txt'), 'utf8'),
+    };
+    await (0, exports.generateStepFiles)(flowDir, stepFiles);
+};
+exports.generateDefaultTemplateSteps = generateDefaultTemplateSteps;

package/dist/src/create/templates/default/steps/api.step.txt

@@ -0,0 +1,29 @@
+import { ApiRouteConfig, StepHandler } from '@motiadev/core'
+import { z } from 'zod'
+
+const inputSchema = z.object({})
+
+export const config: ApiRouteConfig = {
+  type: 'api',
+  name: 'default flow api trigger',
+  description: 'default template api trigger',
+  path: '/default',
+  method: 'POST',
+  emits: ['test-state'],
+  bodySchema: inputSchema,
+  flows: ['default'],
+}
+
+export const handler: StepHandler<typeof config> = async (req, { logger, emit }) => {
+  logger.info('processing default flow api step', req)
+
+  await emit({
+    type: 'test-state',
+    data: {},
+  })
+
+  return {
+    status: 200,
+    body: { message: 'test-state topic emitted' },
+  }
+}

package/dist/src/create/templates/default/steps/one.step.txt

@@ -0,0 +1,29 @@
+import { EventConfig, StepHandler } from '@motiadev/core'
+import { z } from 'zod'
+import equal from 'deep-equal'
+
+type Input = typeof inputSchema
+
+const inputSchema = z.object({})
+
+export const config: EventConfig<Input> = {
+  type: 'event',
+  name: 'Set state change',
+  description: 'set a state change for evaluation',
+  subscribes: ['test-state'],
+  emits: ['check-state-change'],
+  input: inputSchema,
+  flows: ['default'],
+}
+
+export const handler: StepHandler<typeof config> = async (input, { traceId, logger, state, emit }) => {
+  logger.info('step one, set a value in state')
+
+  const message = 'welcome to motia!';
+  await state.set<any>(traceId, 'test', message)
+
+  await emit({
+    type: 'check-state-change',
+    data: {key: 'test', expected: message}
+  })
+}

package/dist/src/create/templates/default/steps/two.step.txt

@@ -0,0 +1,32 @@
+import { EventConfig, StepHandler } from '@motiadev/core'
+import { z } from 'zod'
+import equal from 'deep-equal'
+
+type Input = typeof inputSchema
+
+const inputSchema = z.object({
+  key: z.string(),
+  expected: z.optional(z.unknown()),
+})
+
+export const config: EventConfig<Input> = {
+  type: 'event',
+  name: 'Check state change',
+  description: 'check state change',
+  subscribes: ['check-state-change'],
+  emits: [],
+  input: inputSchema,
+  flows: ['default'],
+}
+
+export const handler: StepHandler<typeof config> = async (input, { traceId, logger, state }) => {
+  logger.info('received check-state-change event', input)
+
+  const value = await state.get<any>(traceId, input.key)
+
+  if (value !== input.expected) {
+    logger.error(`🔴 the provided  value for the state key ${input.key} does not match`, { value, expected: input.expected })
+  } else {
+    logger.info(`🟢 the provided value matches the state value for key ${input.key} 🏁`)
+  }
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templates = void 0;
+const generate_1 = require("./default/generate");
+exports.templates = {
+    default: generate_1.generateDefaultTemplateSteps,
+};

package/dist/src/dev.js

@@ -7,6 +7,7 @@ exports.dev = void 0;
 const core_1 = require("@motiadev/core");
 const generate_locked_data_1 = require("./generate-locked-data");
 const path_1 = __importDefault(require("path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
     transpileOnly: true,
     compilerOptions: { module: 'commonjs' },
@@ -25,6 +26,7 @@ const dev = async (port) => {
     server.listen(port);
     console.log('🚀 Server ready and listening on port', port);
     console.log(`🔗 Open http://localhost:${port}/ to open workbench 🛠️`);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { applyMiddleware } = require('@motiadev/workbench/dist/middleware');
     await applyMiddleware(app);
     // 6) Gracefully shut down on SIGTERM

package/dist/src/generate-locked-data.js

@@ -10,8 +10,9 @@ const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const core_1 = require("@motiadev/core");
 const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
-const baseFlowRegex = new RegExp(/flows\"?\s?.*\s*\[([^\]]+)\]/);
+const baseFlowRegex = new RegExp(/flows"?\s?.*\s*\[([^\]]+)\]/);
 // Helper function to read config.yml
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const readConfig = (configPath) => {
     if (!fs_1.default.existsSync(configPath)) {
         console.warn(`Config file not found at ${configPath}`);
@@ -43,7 +44,7 @@ const collectFlows = async (baseDir) => {
         if (item.isDirectory()) {
             steps = steps.concat(await collectFlows(itemPath));
         }
-        else if (!!item.name.match(/\.step\.(ts|js|py|rb)$/)) {
+        else if (item.name.match(/\.step\.(ts|js|py|rb)$/)) {
             const fileContent = fs_1.default.readFileSync(itemPath, 'utf-8');
             const flowMatch = fileContent.match(baseFlowRegex);
             const config = await extractStepConfig(itemPath);

package/package.json

@@ -1,25 +1,29 @@
 {
   "name": "motia",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "license": "MIT",
   "bin": {
     "motia": "dist/src/cli.js"
   },
   "dependencies": {
-    "dotenv": "^16.4.7",
     "commander": "^13.0.0",
+    "dotenv": "^16.4.7",
+    "figlet": "^1.8.0",
     "ts-node": "^10.9.2",
     "yaml": "^2.7.0",
-    "@motiadev/core": "0.0.16",
-    "@motiadev/workbench": "0.0.16"
+    "@motiadev/core": "0.0.18",
+    "@motiadev/workbench": "0.0.18"
   },
   "devDependencies": {
+    "@types/figlet": "^1.7.0",
     "@types/jest": "^29.5.14",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.7.2"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc"
+    "move:templates": "sh scripts/move-templates.sh",
+    "build": "rm -rf dist && tsc && pnpm run move:templates",
+    "lint": "eslint --config ../../eslint.config.js"
   }
 }

package/scripts/move-templates.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# Define source and destination directories
+SRC_DIR="$(dirname "$0")/../src/create/templates"
+DEST_DIR="$(dirname "$0")/../dist/src/create/templates"
+
+# Create the destination directory if it doesn't exist
+mkdir -p "$DEST_DIR"
+
+# Copy all .txt files while preserving the directory structure
+find "$SRC_DIR" -type f -name "*.txt" | while read -r file; do
+  # Get the relative path of the file
+  rel_path="${file#$SRC_DIR/}"
+  # Create the destination directory for the file
+  mkdir -p "$DEST_DIR/$(dirname "$rel_path")"
+  # Copy the file to the destination directory
+  cp "$file" "$DEST_DIR/$rel_path"
+done
+
+echo "All .txt files have been copied successfully."