@motiadev/core 0.13.2-beta.164-110989 → 0.14.0-beta.164

package/dist/src/analytics/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackEvent = exports.isAnalyticsEnabled = exports.getProjectIdentifier = exports.getUserIdentifier = exports.getProjectName = void 0;
+const analytics_node_1 = require("@amplitude/analytics-node");
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const getProjectName = (baseDir) => {
+    const packageJsonPath = path_1.default.join(baseDir, 'package.json');
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.name || path_1.default.basename(baseDir);
+    }
+    return 'unknown';
+};
+exports.getProjectName = getProjectName;
+const getUserIdentifier = () => {
+    const userInfo = `${os_1.default.userInfo().username}${os_1.default.hostname()}`;
+    return crypto_1.default.createHash('sha256').update(userInfo).digest('hex').substring(0, 16);
+};
+exports.getUserIdentifier = getUserIdentifier;
+const getProjectIdentifier = (baseDir) => {
+    try {
+        return crypto_1.default.createHash('sha256').update((0, exports.getProjectName)(baseDir)).digest('hex').substring(0, 16);
+    }
+    catch (error) {
+        return 'unknown';
+    }
+};
+exports.getProjectIdentifier = getProjectIdentifier;
+const isAnalyticsEnabled = () => {
+    return process.env.MOTIA_ANALYTICS_DISABLED !== 'true';
+};
+exports.isAnalyticsEnabled = isAnalyticsEnabled;
+const trackEvent = (eventName, properties = {}) => {
+    try {
+        if ((0, exports.isAnalyticsEnabled)()) {
+            (0, analytics_node_1.track)(eventName, properties, {
+                user_id: (0, exports.getUserIdentifier)() || 'unknown',
+            });
+        }
+    }
+    catch (error) {
+        // Silently fail to not disrupt dev server
+    }
+};
+exports.trackEvent = trackEvent;

package/dist/src/call-step-file.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from './logger';
+import type { Motia } from './motia';
+import type { Tracer } from './observability';
+import type { InfrastructureConfig, Step } from './types';
+type CallStepFileOptions = {
+    step: Step;
+    traceId: string;
+    data?: unknown;
+    contextInFirstArg?: boolean;
+    logger: Logger;
+    tracer: Tracer;
+    infrastructure?: Partial<InfrastructureConfig>;
+};
+export declare const callStepFile: <TData>(options: CallStepFileOptions, motia: Motia) => Promise<TData | undefined>;
+export {};
+//# sourceMappingURL=call-step-file.d.ts.map

package/dist/src/call-step-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-step-file.d.ts","sourceRoot":"","sources":["../../src/call-step-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAG7C,OAAO,KAAK,EAAS,oBAAoB,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAahE,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAA;CAC/C,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,KAAK,EAAE,SAAS,mBAAmB,EAAE,OAAO,KAAK,KAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAuNzG,CAAA"}

package/dist/src/call-step-file.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callStepFile = void 0;
+const utils_1 = require("./analytics/utils");
+const language_runner_1 = require("./language-runner");
+const process_manager_1 = require("./process-communication/process-manager");
+const utils_2 = require("./utils");
+const callStepFile = (options, motia) => {
+    const { step, traceId, data, tracer, logger, contextInFirstArg = false, infrastructure } = options;
+    const flows = step.config.flows;
+    return new Promise((resolve, reject) => {
+        const streamConfig = motia.lockedData.getStreams();
+        const streams = Object.keys(streamConfig).map((name) => ({ name }));
+        const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg, streams });
+        const { runner, command, args } = (0, language_runner_1.getLanguageBasedRunner)(step.filePath);
+        let result;
+        let timeoutId;
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, step.filePath, jsonData],
+            logger,
+            context: 'StepExecution',
+            projectRoot: motia.lockedData.baseDir,
+        });
+        (0, utils_1.trackEvent)('step_execution_started', {
+            stepName: step.config.name,
+            language: command,
+            type: step.config.type,
+            streams: streams.length,
+        });
+        const timeoutSeconds = infrastructure?.handler?.timeout;
+        if (timeoutSeconds) {
+            timeoutId = setTimeout(async () => {
+                processManager.kill();
+                const errorMessage = `Step execution timed out after ${timeoutSeconds} seconds`;
+                logger.error(errorMessage, { step: step.config.name, timeout: timeoutSeconds });
+                await tracer.end({ message: errorMessage });
+                (0, utils_1.trackEvent)('step_execution_timeout', {
+                    stepName: step.config.name,
+                    traceId,
+                    timeout: timeoutSeconds,
+                });
+                reject(new Error(errorMessage));
+            }, timeoutSeconds * 1000);
+        }
+        processManager
+            .spawn()
+            .then(() => {
+            processManager.handler('close', async (err) => {
+                if (err) {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    processManager.close();
+                    (0, utils_1.trackEvent)('step_execution_error', {
+                        stepName: step.config.name,
+                        traceId,
+                        message: err.message,
+                    });
+                    await tracer.end({
+                        message: err.message,
+                        code: err.code,
+                        stack: err.stack?.replace(new RegExp(`${motia.lockedData.baseDir}/`), ''),
+                    });
+                    const error = err ?? new Error('Handler execution failed');
+                    reject(error);
+                }
+                else {
+                    await tracer.end();
+                }
+                processManager.kill();
+            });
+            processManager.handler('log', async (input) => logger.log(input));
+            processManager.handler('state.get', async (input) => {
+                await tracer.stateOperation('get', input);
+                return motia.state.get(input.traceId, input.key);
+            });
+            processManager.handler('state.set', async (input) => {
+                await tracer.stateOperation('set', { traceId: input.traceId, key: input.key, value: input.value });
+                return motia.state.set(input.traceId, input.key, input.value);
+            });
+            processManager.handler('state.delete', async (input) => {
+                await tracer.stateOperation('delete', input);
+                return motia.state.delete(input.traceId, input.key);
+            });
+            processManager.handler('state.clear', async (input) => {
+                await tracer.stateOperation('clear', input);
+                return motia.state.clear(input.traceId);
+            });
+            processManager.handler(`state.getGroup`, async (input) => {
+                await tracer.stateOperation('getGroup', input);
+                return motia.state.getGroup(input.groupId);
+            });
+            processManager.handler('result', async (input) => {
+                const anyInput = { ...input };
+                if (anyInput.body && anyInput.body.type === 'Buffer') {
+                    anyInput.body = Buffer.from(anyInput.body.data);
+                }
+                result = anyInput;
+            });
+            processManager.handler('emit', async (input) => {
+                const flows = step.config.flows;
+                if (!(0, utils_2.isAllowedToEmit)(step, input.topic)) {
+                    await tracer.emitOperation(input.topic, input.data, false);
+                    return motia.printer.printInvalidEmit(step, input.topic);
+                }
+                await tracer.emitOperation(input.topic, input.data, true);
+                return motia.eventAdapter.emit({ ...input, traceId, flows, logger, tracer });
+            });
+            Object.entries(streamConfig).forEach(([name, streamFactory]) => {
+                const stateStream = streamFactory();
+                processManager.handler(`streams.${name}.get`, async (input) => {
+                    await tracer.streamOperation(name, 'get', input);
+                    return stateStream.get(input.groupId, input.id);
+                });
+                processManager.handler(`streams.${name}.set`, async (input) => {
+                    await tracer.streamOperation(name, 'set', { groupId: input.groupId, id: input.id, data: input.data });
+                    return stateStream.set(input.groupId, input.id, input.data);
+                });
+                processManager.handler(`streams.${name}.delete`, async (input) => {
+                    await tracer.streamOperation(name, 'delete', input);
+                    return stateStream.delete(input.groupId, input.id);
+                });
+                processManager.handler(`streams.${name}.getGroup`, async (input) => {
+                    await tracer.streamOperation(name, 'getGroup', input);
+                    return stateStream.getGroup(input.groupId);
+                });
+                processManager.handler(`streams.${name}.send`, async (input) => {
+                    await tracer.streamOperation(name, 'send', input);
+                    return stateStream.send(input.channel, input.event);
+                });
+            });
+            processManager.onStdout((data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    logger.log(message);
+                }
+                catch {
+                    logger.info(Buffer.from(data).toString());
+                }
+            });
+            processManager.onStderr((data) => logger.error(Buffer.from(data).toString()));
+            processManager.onProcessClose(async (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                processManager.close();
+                if (code !== 0 && code !== null) {
+                    const error = { message: `Process exited with code ${code}`, code };
+                    await tracer.end(error);
+                    (0, utils_1.trackEvent)('step_execution_error', { stepName: step.config.name, traceId, code });
+                    reject(`Process exited with code ${code}`);
+                }
+                else {
+                    await tracer.end();
+                    resolve(result);
+                }
+            });
+            processManager.onProcessError(async (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                processManager.close();
+                await tracer.end({
+                    message: error.message,
+                    code: error.code,
+                    stack: error.stack,
+                });
+                if (error.code === 'ENOENT') {
+                    (0, utils_1.trackEvent)('step_execution_error', {
+                        stepName: step.config.name,
+                        traceId,
+                        code: error.code,
+                        message: error.message,
+                    });
+                    reject(`Executable ${command} not found`);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        })
+            .catch(async (error) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            await tracer.end({
+                message: error.message,
+                code: error.code,
+                stack: error.stack,
+            });
+            (0, utils_1.trackEvent)('step_execution_error', {
+                stepName: step.config.name,
+                traceId,
+                code: error.code,
+                message: error.message,
+            });
+            reject(`Failed to spawn process: ${error}`);
+        });
+    });
+};
+exports.callStepFile = callStepFile;

package/dist/src/config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from './types/app-config-types';
+export declare const config: (config: Config) => Config;
+//# sourceMappingURL=config.d.ts.map

package/dist/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAA;AAEtD,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,KAAG,MAAgB,CAAA"}

package/dist/src/config.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const config = (config) => config;
+exports.config = config;

package/dist/src/config.types.d.ts

@@ -0,0 +1,17 @@
+import type { StepConfig } from './types';
+export type StateConfig = {
+    adapter: string;
+    host: string;
+    port: number;
+    password?: string;
+};
+export type Config = {
+    port: number;
+    state: StateConfig;
+};
+export type Step<TConfig extends StepConfig = StepConfig> = {
+    config: TConfig;
+    file: string;
+    filePath: string;
+};
+//# sourceMappingURL=config.types.d.ts.map

package/dist/src/config.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.types.d.ts","sourceRoot":"","sources":["../../src/config.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,WAAW,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,IAAI,CAAC,OAAO,SAAS,UAAU,GAAG,UAAU,IAAI;IAC1D,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA"}

package/dist/src/config.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/cron-handler.d.ts

@@ -0,0 +1,14 @@
+import type { CronAdapter } from './adapters/interfaces/cron-adapter.interface';
+import type { Motia } from './motia';
+import type { CronConfig, Step } from './types';
+export type CronManager = {
+    createCronJob: (step: Step<CronConfig>) => void;
+    removeCronJob: (step: Step<CronConfig>) => void;
+    close: () => Promise<void>;
+};
+export declare const setupCronHandlers: (motia: Motia, cronAdapter?: CronAdapter) => {
+    createCronJob: (step: Step<CronConfig>) => void;
+    removeCronJob: (step: Step<CronConfig>) => void;
+    close: () => Promise<void>;
+};
+//# sourceMappingURL=cron-handler.d.ts.map

package/dist/src/cron-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-handler.d.ts","sourceRoot":"","sources":["../../src/cron-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAY,MAAM,8CAA8C,CAAA;AAIzF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAE/C,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IAC/C,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IAC/C,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,EAAE,cAAc,WAAW;0BAG1C,IAAI,CAAC,UAAU,CAAC;0BA8EhB,IAAI,CAAC,UAAU,CAAC;;CAqB9C,CAAA"}

package/dist/src/cron-handler.js

@@ -0,0 +1,132 @@
+"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.setupCronHandlers = void 0;
+const cron = __importStar(require("node-cron"));
+const call_step_file_1 = require("./call-step-file");
+const generate_trace_id_1 = require("./generate-trace-id");
+const logger_1 = require("./logger");
+const setupCronHandlers = (motia, cronAdapter) => {
+    const cronJobs = new Map();
+    const createCronJob = (step) => {
+        const { config, filePath } = step;
+        const { cron: cronExpression, name: stepName, flows } = config;
+        if (!cron.validate(cronExpression)) {
+            logger_1.globalLogger.error('[cron handler] invalid cron expression', {
+                expression: cronExpression,
+                step: stepName,
+            });
+            return;
+        }
+        logger_1.globalLogger.debug('[cron handler] setting up cron job', {
+            filePath,
+            step: stepName,
+            cron: cronExpression,
+        });
+        const task = cron.schedule(cronExpression, async () => {
+            let lock = null;
+            if (cronAdapter) {
+                try {
+                    lock = await cronAdapter.acquireLock(stepName, 300000);
+                    if (!lock) {
+                        logger_1.globalLogger.debug('[cron handler] failed to acquire lock, skipping execution', {
+                            step: stepName,
+                        });
+                        return;
+                    }
+                    logger_1.globalLogger.debug('[cron handler] acquired lock for cron job', {
+                        step: stepName,
+                        lockId: lock.lockId,
+                        instanceId: lock.instanceId,
+                    });
+                }
+                catch (error) {
+                    logger_1.globalLogger.error('[cron handler] error acquiring lock', {
+                        error: error.message,
+                        step: stepName,
+                    });
+                    return;
+                }
+            }
+            const traceId = (0, generate_trace_id_1.generateTraceId)();
+            const logger = motia.loggerFactory.create({ traceId, flows, stepName });
+            const tracer = await motia.tracerFactory.createTracer(traceId, step, logger);
+            try {
+                await (0, call_step_file_1.callStepFile)({ contextInFirstArg: true, step, traceId, tracer, logger }, motia);
+            }
+            catch (error) {
+                logger.error('[cron handler] error executing cron job', {
+                    error: error.message,
+                    step: step.config.name,
+                });
+            }
+            finally {
+                if (lock && cronAdapter) {
+                    try {
+                        await cronAdapter.releaseLock(lock);
+                        logger_1.globalLogger.debug('[cron handler] released lock for cron job', {
+                            step: stepName,
+                            lockId: lock.lockId,
+                        });
+                    }
+                    catch (error) {
+                        logger_1.globalLogger.error('[cron handler] error releasing lock', {
+                            error: error.message,
+                            step: stepName,
+                        });
+                    }
+                }
+            }
+        });
+        cronJobs.set(step.filePath, task);
+    };
+    const removeCronJob = (step) => {
+        const task = cronJobs.get(step.filePath);
+        if (task) {
+            task.stop();
+            cronJobs.delete(step.filePath);
+        }
+    };
+    const close = async () => {
+        cronJobs.forEach((task) => task.stop());
+        cronJobs.clear();
+        if (cronAdapter) {
+            await cronAdapter.shutdown();
+        }
+    };
+    motia.lockedData.cronSteps().forEach(createCronJob);
+    return { createCronJob, removeCronJob, close };
+};
+exports.setupCronHandlers = setupCronHandlers;

package/dist/src/endpoints/analytics-endpoint.d.ts

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+export declare const analyticsEndpoint: (app: Express, baseDir: string) => void;
+//# sourceMappingURL=analytics-endpoint.d.ts.map

package/dist/src/endpoints/analytics-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics-endpoint.d.ts","sourceRoot":"","sources":["../../../src/endpoints/analytics-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAGtC,eAAO,MAAM,iBAAiB,GAAI,KAAK,OAAO,EAAE,SAAS,MAAM,SAyB9D,CAAA"}

package/dist/src/endpoints/analytics-endpoint.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsEndpoint = void 0;
+const utils_1 = require("../analytics/utils");
+const analyticsEndpoint = (app, baseDir) => {
+    app.get('/motia/analytics/user', (_req, res) => {
+        const analyticsEnabled = (0, utils_1.isAnalyticsEnabled)();
+        if (!analyticsEnabled) {
+            res.json({
+                userId: null,
+                projectId: null,
+                motiaVersion: null,
+                analyticsEnabled: false,
+            });
+            return;
+        }
+        res.json({
+            userId: (0, utils_1.getUserIdentifier)(),
+            projectId: (0, utils_1.getProjectIdentifier)(baseDir),
+            motiaVersion: process.env.npm_package_dependencies_motia || 'unknown',
+            analyticsEnabled: true,
+        });
+    });
+    app.get('/motia/analytics/status', (_req, res) => {
+        res.json({ analyticsEnabled: (0, utils_1.isAnalyticsEnabled)() });
+    });
+};
+exports.analyticsEndpoint = analyticsEndpoint;

package/dist/src/endpoints/flows-config-endpoint.d.ts

@@ -0,0 +1,4 @@
+import type { Express } from 'express';
+import type { LockedData } from '../locked-data';
+export declare const flowsConfigEndpoint: (app: Express, baseDir: string, lockedData: LockedData) => void;
+//# sourceMappingURL=flows-config-endpoint.d.ts.map

package/dist/src/endpoints/flows-config-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flows-config-endpoint.d.ts","sourceRoot":"","sources":["../../../src/endpoints/flows-config-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAA;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAQhD,eAAO,MAAM,mBAAmB,GAAI,KAAK,OAAO,EAAE,SAAS,MAAM,EAAE,YAAY,UAAU,SA2BxF,CAAA"}

package/dist/src/endpoints/flows-config-endpoint.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowsConfigEndpoint = void 0;
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const flows_config_stream_1 = require("../streams/flows-config-stream");
+const flowsConfigEndpoint = (app, baseDir, lockedData) => {
+    const configPath = path_1.default.join(baseDir, 'motia-workbench.json');
+    const stream = new flows_config_stream_1.FlowsConfigStream(configPath);
+    lockedData.createStream({
+        filePath: '__motia.flowsConfig',
+        hidden: true,
+        config: {
+            name: '__motia.flowsConfig',
+            schema: zod_1.z.object({ name: zod_1.z.string(), steps: zod_1.z.any(), edges: zod_1.z.any() }),
+            baseConfig: { storageType: 'custom', factory: () => stream },
+        },
+    }, { disableTypeCreation: true })();
+    app.post('/__motia/flows/:id/config', async (req, res) => {
+        const newFlowConfig = req.body;
+        try {
+            await stream.set('default', newFlowConfig.id, newFlowConfig);
+            res.status(200).send({ message: 'Flow config saved successfully' });
+        }
+        catch (error) {
+            console.error('Error saving flow config:', error.message);
+            res.status(500).json({ error: 'Failed to save flow config' });
+        }
+    });
+};
+exports.flowsConfigEndpoint = flowsConfigEndpoint;

package/dist/src/endpoints/flows-endpoint.d.ts

@@ -0,0 +1,3 @@
+import type { LockedData } from '../locked-data';
+export declare const flowsEndpoint: (lockedData: LockedData) => void;
+//# sourceMappingURL=flows-endpoint.d.ts.map

package/dist/src/endpoints/flows-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flows-endpoint.d.ts","sourceRoot":"","sources":["../../../src/endpoints/flows-endpoint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD,eAAO,MAAM,aAAa,GAAI,YAAY,UAAU,SA2BnD,CAAA"}

package/dist/src/endpoints/flows-endpoint.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowsEndpoint = void 0;
+const zod_1 = require("zod");
+const flows_helper_1 = require("../helper/flows-helper");
+const flows_stream_1 = require("../streams/flows-stream");
+const flowsEndpoint = (lockedData) => {
+    const flowsStream = lockedData.createStream({
+        filePath: '__motia.flows',
+        hidden: true,
+        config: {
+            name: '__motia.flows',
+            schema: zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string(), steps: zod_1.z.any(), edges: zod_1.z.any() }),
+            baseConfig: { storageType: 'custom', factory: () => new flows_stream_1.FlowsStream(lockedData) },
+        },
+    }, { disableTypeCreation: true })();
+    lockedData.on('flow-created', (flowId) => {
+        const flow = lockedData.flows[flowId];
+        const response = (0, flows_helper_1.generateFlow)(flowId, flow.steps);
+        flowsStream.set('default', flowId, response);
+    });
+    lockedData.on('flow-updated', (flowId) => {
+        const flow = lockedData.flows[flowId];
+        const response = (0, flows_helper_1.generateFlow)(flowId, flow.steps);
+        flowsStream.set('default', flowId, response);
+    });
+    lockedData.on('flow-removed', (flowId) => flowsStream.delete('default', flowId));
+};
+exports.flowsEndpoint = flowsEndpoint;

package/dist/src/endpoints/step-endpoint.d.ts

@@ -0,0 +1,4 @@
+import type { Express } from 'express';
+import type { LockedData } from '../locked-data';
+export declare const stepEndpoint: (app: Express, lockedData: LockedData) => void;
+//# sourceMappingURL=step-endpoint.d.ts.map

package/dist/src/endpoints/step-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-endpoint.d.ts","sourceRoot":"","sources":["../../../src/endpoints/step-endpoint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAGtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAiBhD,eAAO,MAAM,YAAY,GAAI,KAAK,OAAO,EAAE,YAAY,UAAU,SA0BhE,CAAA"}

package/dist/src/endpoints/step-endpoint.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepEndpoint = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const flows_helper_1 = require("../helper/flows-helper");
+const getFeatures = async (filePath) => {
+    const stat = await promises_1.default.stat(`${filePath}-features.json`).catch(() => null);
+    if (!stat || stat.isDirectory()) {
+        return [];
+    }
+    try {
+        const content = await promises_1.default.readFile(`${filePath}-features.json`, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+};
+const stepEndpoint = (app, lockedData) => {
+    app.get('/__motia/step/:stepId', async (req, res) => {
+        const id = req.params.stepId;
+        const allSteps = [...lockedData.activeSteps, ...lockedData.devSteps];
+        const step = allSteps.find((step) => (0, flows_helper_1.generateStepId)(step.filePath) === id);
+        if (!step) {
+            res.status(404).send({ error: 'Step not found' });
+            return;
+        }
+        try {
+            const content = await promises_1.default.readFile(step.filePath, 'utf8');
+            const features = await getFeatures(step.filePath.replace(`${node_path_1.default.sep}steps${node_path_1.default.sep}`, `${node_path_1.default.sep}tutorial${node_path_1.default.sep}`));
+            res.status(200).send({ id, content, features });
+        }
+        catch (error) {
+            console.error('Error reading step file:', error);
+            res.status(500).send({
+                error: 'Failed to read step file',
+            });
+        }
+    });
+};
+exports.stepEndpoint = stepEndpoint;

package/dist/src/generate-trace-id.d.ts

@@ -0,0 +1,3 @@
+export declare const generateCode: (length?: number) => string;
+export declare const generateTraceId: () => string;
+//# sourceMappingURL=generate-trace-id.d.ts.map

package/dist/src/generate-trace-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-trace-id.d.ts","sourceRoot":"","sources":["../../src/generate-trace-id.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,eAAU,WAGtC,CAAA;AAED,eAAO,MAAM,eAAe,cAI3B,CAAA"}