motia 0.0.19 → 0.0.21

package/dist/src/dev-watchers.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevWatchers = void 0;
+const core_1 = require("@motiadev/core");
+const watcher_1 = require("./watcher");
+const path_1 = __importDefault(require("path"));
+const createDevWatchers = (lockedData, server, eventHandler, cronManager) => {
+    const stepDir = path_1.default.join(process.cwd(), 'steps');
+    const watcher = new watcher_1.Watcher(stepDir, lockedData);
+    lockedData.on('flow-created', (flowName) => {
+        server.socketServer.emit('flow-created', flowName);
+    });
+    lockedData.on('flow-removed', (flowName) => {
+        server.socketServer.emit('flow-removed', flowName);
+    });
+    lockedData.on('flow-updated', (flowName) => {
+        server.socketServer.emit('flow-updated', flowName);
+    });
+    watcher.onStepChange((oldStep, newStep) => {
+        if ((0, core_1.isApiStep)(oldStep))
+            server.removeRoute(oldStep);
+        if ((0, core_1.isCronStep)(oldStep))
+            cronManager.removeCronJob(oldStep);
+        if ((0, core_1.isEventStep)(oldStep))
+            eventHandler.removeHandler(oldStep);
+        const isUpdated = lockedData.updateStep(oldStep, newStep);
+        if (isUpdated) {
+            if ((0, core_1.isCronStep)(newStep))
+                cronManager.createCronJob(newStep);
+            if ((0, core_1.isEventStep)(newStep))
+                eventHandler.createHandler(newStep);
+            if ((0, core_1.isApiStep)(newStep))
+                server.addRoute(newStep);
+        }
+    });
+    watcher.onStepCreate((step) => {
+        const isCreated = lockedData.createStep(step);
+        if (isCreated) {
+            if ((0, core_1.isApiStep)(step))
+                server.addRoute(step);
+            if ((0, core_1.isEventStep)(step))
+                eventHandler.createHandler(step);
+            if ((0, core_1.isCronStep)(step))
+                cronManager.createCronJob(step);
+        }
+    });
+    watcher.onStepDelete((step) => {
+        if ((0, core_1.isApiStep)(step))
+            server.removeRoute(step);
+        if ((0, core_1.isEventStep)(step))
+            eventHandler.removeHandler(step);
+        if ((0, core_1.isCronStep)(step))
+            cronManager.removeCronJob(step);
+        lockedData.deleteStep(step);
+    });
+    return watcher;
+};
+exports.createDevWatchers = createDevWatchers;

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"));
+const dev_watchers_1 = require("./dev-watchers");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
     transpileOnly: true,
@@ -14,25 +15,27 @@ require('ts-node').register({
 });
 const dev = async (port) => {
     const lockedData = await (0, generate_locked_data_1.generateLockedData)(process.cwd());
-    const steps = [...lockedData.steps.active, ...lockedData.steps.dev];
     const eventManager = (0, core_1.createEventManager)();
     const state = (0, core_1.createStateAdapter)({
         adapter: 'default',
         filePath: path_1.default.join(process.cwd(), '.motia'),
     });
     await state.init();
-    const { app, server } = await (0, core_1.createServer)({ steps, state, flows: lockedData.flows, eventManager });
-    (0, core_1.createStepHandlers)(steps, eventManager, state);
-    server.listen(port);
+    const motiaServer = await (0, core_1.createServer)(lockedData, eventManager, state);
+    const motiaEventManager = (0, core_1.createStepHandlers)(lockedData, eventManager, state);
+    const watcher = (0, dev_watchers_1.createDevWatchers)(lockedData, motiaServer, motiaEventManager, motiaServer.cronManager);
+    watcher.init();
+    motiaServer.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);
+    await applyMiddleware(motiaServer.app);
     // 6) Gracefully shut down on SIGTERM
     process.on('SIGTERM', async () => {
         core_1.globalLogger.info('🛑 Shutting down...');
-        server.close();
+        motiaServer.server.close();
+        await watcher.stop();
         process.exit(0);
     });
 };

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

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateLockedData = void 0;
+exports.generateLockedData = exports.readConfig = void 0;
+const core_1 = require("@motiadev/core");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
 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*\[([^\]]+)\]/);
 // Helper function to read config.yml
@@ -21,99 +21,40 @@ const readConfig = (configPath) => {
     const configContent = fs_1.default.readFileSync(configPath, 'utf-8');
     return yaml_1.default.parse(configContent);
 };
-const extractStepConfig = (filePath) => {
-    const isRb = filePath.endsWith('.rb');
-    const isPython = filePath.endsWith('.py');
-    const isNode = filePath.endsWith('.js') || filePath.endsWith('.ts');
-    if (isRb) {
-        return (0, core_1.getRubyConfig)(filePath);
-    }
-    if (isPython) {
-        return (0, core_1.getPythonConfig)(filePath);
-    }
-    if (isNode) {
-        return (0, core_1.getNodeFileConfig)(filePath);
-    }
-};
+exports.readConfig = readConfig;
 // Helper function to recursively collect flow data
 const collectFlows = async (baseDir) => {
     const folderItems = fs_1.default.readdirSync(baseDir, { withFileTypes: true });
     let steps = [];
     for (const item of folderItems) {
-        const itemPath = path_1.default.join(baseDir, item.name);
+        const filePath = path_1.default.join(baseDir, item.name);
         if (item.isDirectory()) {
-            steps = steps.concat(await collectFlows(itemPath));
+            steps = steps.concat(await collectFlows(filePath));
         }
         else if (item.name.match(/\.step\.(ts|js|py|rb)$/)) {
-            const fileContent = fs_1.default.readFileSync(itemPath, 'utf-8');
+            const fileContent = fs_1.default.readFileSync(filePath, 'utf-8');
             const flowMatch = fileContent.match(baseFlowRegex);
-            const config = await extractStepConfig(itemPath);
+            const config = await (0, core_1.getStepConfig)(filePath);
             if (!config) {
-                console.warn(`No config found in step ${itemPath}, step skipped`);
+                console.warn(`No config found in step ${filePath}, step skipped`);
                 continue;
             }
             if (flowMatch) {
-                steps.push({
-                    // TODO: when the lock file comes back, this needs to be updated to use a relative path
-                    filePath: itemPath,
-                    version,
-                    config,
-                });
+                steps.push({ filePath, version, config });
             }
         }
     }
     return steps;
 };
 const generateLockedData = async (projectDir) => {
-    const configPath = path_1.default.join(projectDir, 'config.yml');
-    // NOTE: right now for performance and simplicity let's enforce a folder, but we might want to remove this and scan the entire current directory
-    const stepsPath = path_1.default.join(projectDir, 'steps');
     try {
-        const config = readConfig(configPath);
-        // Collect steps data from steps folder
-        const sourceSteps = await collectFlows(stepsPath);
-        const { flows, steps } = sourceSteps.reduce((acc, step) => {
-            const nextSteps = { ...acc.steps };
-            // NOTE: identifies a noop step
-            if (step.config.virtualEmits) {
-                nextSteps.dev.push(step);
-            }
-            else {
-                nextSteps.active.push(step);
-            }
-            const nextFlows = { ...acc.flows };
-            step.config.flows.forEach((flowName) => {
-                if (!nextFlows[flowName]) {
-                    nextFlows[flowName] = {
-                        name: flowName,
-                        // TODO: how are we going to extract descriptions?
-                        description: '',
-                        steps: [],
-                    };
-                }
-                nextFlows[flowName].steps.push(step);
-            });
-            return {
-                ...acc,
-                steps: nextSteps,
-                flows: nextFlows,
-            };
-        }, {
-            flows: {},
-            steps: {
-                active: [],
-                dev: [],
-            },
-        });
-        // Prepare the lock file data
-        const lockedData = {
-            baseDir: projectDir,
-            state: config?.state || {},
-            steps,
-            flows,
-        };
-        console.log('Project config loaded');
-        // TODO: for now this will return the locked data as an object, in the future we will write it to a lock file
+        /*
+         * NOTE: right now for performance and simplicity let's enforce a folder,
+         * but we might want to remove this and scan the entire current directory
+         */
+        const sourceSteps = await collectFlows(path_1.default.join(projectDir, 'steps'));
+        const lockedData = new core_1.LockedData(projectDir);
+        sourceSteps.forEach((step) => lockedData.createStep(step));
         return lockedData;
     }
     catch (error) {

package/dist/src/watcher.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watcher = void 0;
+const chokidar_1 = __importDefault(require("chokidar"));
+const crypto_1 = require("crypto");
+const core_1 = require("@motiadev/core");
+class Watcher {
+    constructor(dir, lockedData) {
+        this.dir = dir;
+        this.lockedData = lockedData;
+    }
+    onStepChange(handler) {
+        this.stepChangeHandler = handler;
+    }
+    onStepCreate(handler) {
+        this.stepCreateHandler = handler;
+    }
+    onStepDelete(handler) {
+        this.stepDeleteHandler = handler;
+    }
+    findStep(path) {
+        return (this.lockedData.activeSteps.find((step) => step.filePath === path) ||
+            this.lockedData.devSteps.find((step) => step.filePath === path));
+    }
+    async onFileAdd(path) {
+        if (!this.stepCreateHandler) {
+            console.warn(`No step create handler, step skipped`);
+            return;
+        }
+        const config = await (0, core_1.getStepConfig)(path);
+        if (!config) {
+            console.warn(`No config found in step ${path}, step skipped`);
+            return;
+        }
+        const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
+        const step = { filePath: path, version, config };
+        this.stepCreateHandler?.(step);
+    }
+    async onFileChange(path) {
+        if (!this.stepChangeHandler) {
+            console.warn(`No step change handler, step skipped`);
+            return;
+        }
+        const config = await (0, core_1.getStepConfig)(path);
+        const step = this.findStep(path);
+        if (!step && !config) {
+            console.warn(`Step ${path} not found, step skipped`);
+            return;
+        }
+        // didn't have a step, but now we have a config
+        if (!step && config) {
+            const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
+            const step = { filePath: path, version, config };
+            this.stepCreateHandler?.(step);
+        }
+        // had a step, and now we have a config
+        if (step && config) {
+            const newStep = { ...step, config };
+            this.stepChangeHandler?.(step, newStep);
+        }
+        // had a step, but no config
+        if (step && !config) {
+            this.stepDeleteHandler?.(step);
+        }
+    }
+    async onFileDelete(path) {
+        if (!this.stepDeleteHandler) {
+            console.warn(`No step delete handler, step skipped`);
+            return;
+        }
+        const step = this.findStep(path);
+        if (!step) {
+            console.warn(`Step ${path} not found, step skipped`);
+            return;
+        }
+        this.stepDeleteHandler?.(step);
+    }
+    init() {
+        this.watcher = chokidar_1.default
+            .watch(this.dir, { persistent: true, ignoreInitial: true })
+            .on('add', (path) => this.onFileAdd(path))
+            .on('change', (path) => this.onFileChange(path))
+            .on('unlink', (path) => this.onFileDelete(path));
+    }
+    async stop() {
+        if (this.watcher) {
+            await this.watcher.close();
+        }
+    }
+}
+exports.Watcher = Watcher;

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "motia",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "license": "MIT",
   "bin": {
     "motia": "dist/src/cli.js"
   },
   "dependencies": {
+    "chokidar": "^4.0.3",
     "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.19",
-    "@motiadev/workbench": "0.0.19"
+    "@motiadev/core": "0.0.21",
+    "@motiadev/workbench": "0.0.21"
   },
   "devDependencies": {
     "@types/figlet": "^1.7.0",