@motiadev/core 0.2.2 → 0.3.0-beta.78

package/dist/src/observability/trace-manager.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceManager = void 0;
+class TraceManager {
+    constructor(traceStream, traceGroupStream, traceGroup, trace) {
+        this.traceStream = traceStream;
+        this.traceGroupStream = traceGroupStream;
+        this.traceGroup = traceGroup;
+        this.trace = trace;
+        this.updateTrace();
+        this.updateTraceGroup();
+    }
+    updateTrace() {
+        this.traceStream.set(this.traceGroup.id, this.trace.id, this.trace);
+    }
+    updateTraceGroup() {
+        this.traceGroupStream.set('default', this.traceGroup.id, this.traceGroup);
+    }
+    child(trace) {
+        return new TraceManager(this.traceStream, this.traceGroupStream, this.traceGroup, trace);
+    }
+}
+exports.TraceManager = TraceManager;

package/dist/src/observability/tracer.d.ts

@@ -0,0 +1,14 @@
+import { TracerFactory } from '.';
+import { LockedData } from '../locked-data';
+import { Logger } from '../logger';
+import { Step } from '../types';
+import { MotiaStream } from '../types-stream';
+import { StreamTracer } from './stream-tracer';
+import { Trace, TraceGroup } from './types';
+export declare class BaseTracerFactory implements TracerFactory {
+    private readonly traceStream;
+    private readonly traceGroupStream;
+    constructor(traceStream: MotiaStream<Trace>, traceGroupStream: MotiaStream<TraceGroup>);
+    createTracer(traceId: string, step: Step, logger: Logger): StreamTracer;
+}
+export declare const createTracerFactory: (lockedData: LockedData) => TracerFactory;

package/dist/src/observability/tracer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTracerFactory = exports.BaseTracerFactory = void 0;
+const create_trace_1 = require("./create-trace");
+const stream_tracer_1 = require("./stream-tracer");
+const trace_manager_1 = require("./trace-manager");
+class BaseTracerFactory {
+    constructor(traceStream, traceGroupStream) {
+        this.traceStream = traceStream;
+        this.traceGroupStream = traceGroupStream;
+    }
+    createTracer(traceId, step, logger) {
+        const traceGroup = {
+            id: traceId,
+            name: step.config.name,
+            lastActivity: Date.now(),
+            metadata: {
+                completedSteps: 0,
+                activeSteps: 0,
+                totalSteps: 0,
+            },
+            correlationId: undefined,
+            status: 'running',
+            startTime: Date.now(),
+        };
+        const trace = (0, create_trace_1.createTrace)(traceGroup, step);
+        const manager = new trace_manager_1.TraceManager(this.traceStream, this.traceGroupStream, traceGroup, trace);
+        return new stream_tracer_1.StreamTracer(manager, traceGroup, trace, logger);
+    }
+}
+exports.BaseTracerFactory = BaseTracerFactory;
+const createTracerFactory = (lockedData) => {
+    const traceStream = lockedData.createStream({
+        filePath: '__motia.trace',
+        hidden: true,
+        config: {
+            name: 'motia-trace',
+            baseConfig: { storageType: 'default' },
+            schema: null,
+        },
+    })();
+    const traceGroupStream = lockedData.createStream({
+        filePath: '__motia.trace-group',
+        hidden: true,
+        config: {
+            name: 'motia-trace-group',
+            baseConfig: { storageType: 'default' },
+            schema: null,
+        },
+    })();
+    return new BaseTracerFactory(traceStream, traceGroupStream);
+};
+exports.createTracerFactory = createTracerFactory;

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

@@ -0,0 +1,74 @@
+import { StepConfig } from '../types';
+export interface TraceGroup {
+    id: string;
+    correlationId: string | undefined;
+    name: string;
+    status: 'running' | 'completed' | 'failed';
+    startTime: number;
+    endTime?: number;
+    lastActivity: number;
+    metadata: {
+        completedSteps: number;
+        activeSteps: number;
+        totalSteps: number;
+    };
+}
+export type TraceError = {
+    message: string;
+    code?: string | number;
+    stack?: string;
+};
+export interface Trace {
+    id: string;
+    name: string;
+    correlationId?: string;
+    parentTraceId?: string;
+    status: 'running' | 'completed' | 'failed';
+    startTime: number;
+    endTime?: number;
+    error?: TraceError;
+    entryPoint: {
+        type: StepConfig['type'];
+        stepName: string;
+    };
+    events: TraceEvent[];
+}
+export type TraceEvent = StateEvent | EmitEvent | StreamEvent | LogEntry;
+export type StateOperation = 'get' | 'getGroup' | 'set' | 'delete' | 'clear';
+export type StreamOperation = 'get' | 'getGroup' | 'set' | 'delete' | 'clear' | 'send';
+export interface StateEvent {
+    type: 'state';
+    timestamp: number;
+    operation: 'get' | 'getGroup' | 'set' | 'delete' | 'clear';
+    key?: string;
+    duration?: number;
+    data: unknown;
+}
+export interface EmitEvent {
+    type: 'emit';
+    timestamp: number;
+    topic: string;
+    success: boolean;
+    data: unknown;
+}
+export interface StreamEvent {
+    type: 'stream';
+    timestamp: number;
+    operation: StreamOperation;
+    streamName: string;
+    duration?: number;
+    maxTimestamp?: number;
+    data: {
+        groupId: string;
+        id: string;
+        data?: unknown;
+    };
+    calls: number;
+}
+export interface LogEntry {
+    type: 'log';
+    timestamp: number;
+    level: string;
+    message: string;
+    metadata?: unknown;
+}

package/dist/src/observability/types.js

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

package/dist/src/printer.d.ts

@@ -29,7 +29,7 @@ export declare class Printer {
     getStreamPath(stream: Stream): string;
 }
 export declare class NoPrinter extends Printer {
-    constructor(baseDir: string);
+    constructor();
     printInvalidEmit(): void;
     printStepCreated(): void;
     printStepUpdated(): void;

package/dist/src/printer.js

@@ -102,8 +102,8 @@ class Printer {
 }
 exports.Printer = Printer;
 class NoPrinter extends Printer {
-    constructor(baseDir) {
-        super(baseDir);
+    constructor() {
+        super('');
     }
     printInvalidEmit() { }
     printStepCreated() { }

package/dist/src/process-communication/process-manager.d.ts

@@ -1,11 +1,11 @@
 import { ChildProcess } from 'child_process';
 import { CommunicationType } from './communication-config';
 import { RpcHandler, MessageCallback } from './rpc-processor-interface';
-import { BaseLogger } from '../logger';
+import { Logger } from '../logger';
 export interface ProcessManagerOptions {
     command: string;
     args: string[];
-    logger: BaseLogger;
+    logger: Logger;
     context?: string;
 }
 export declare class ProcessManager {

package/dist/src/python/python-runner.py

@@ -4,9 +4,8 @@ import importlib.util
 import os
 import asyncio
 import traceback
-from typing import Optional, Any, Callable, List, Dict
+from typing import Callable, List, Dict
 from rpc import RpcSender
-from type_definitions import FlowConfig, ApiResponse
 from context import Context
 from middleware import compose_middleware
 from rpc_stream_manager import RpcStreamManager
@@ -42,7 +41,6 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
             raise AttributeError(f"Function 'handler' not found in module {file_path}")
 
         config = module.config
-        is_api_handler = (config and config.get("type") == "api")
 
         trace_id = args.get("traceId")
         flows = args.get("flows") or []
@@ -75,9 +73,20 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
         rpc.close()
         
     except Exception as error:
-        print(f'Error running Python module: {error}', file=sys.stderr)
-        traceback.print_exc(file=sys.stderr)
-        sys.exit(1)
+        stack_list = traceback.format_exception(type(error), error, error.__traceback__)
+
+        # We're removing the first two and last item
+        # 0: Traceback (most recent call last):
+        # 1: File "python-runner.py", line 82, in run_python_module
+        # 2: File "python-runner.py", line 69, in run_python_module
+        # -1: Exception: message
+        stack_list = stack_list[3:-1]
+
+        rpc.send_no_wait("close", {
+            "message": str(error),
+            "stack": "\n".join(stack_list)
+        })
+        rpc.close()
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:

package/dist/src/python/type_definitions.py

@@ -1,6 +1,5 @@
 from typing import TypeVar, Callable, Coroutine, Union, Dict, List, Optional
 from types import SimpleNamespace
-from rpc import RpcSender
 
 # Generic type for JSON schema validation
 T = TypeVar('T')

package/dist/src/server.d.ts

@@ -3,7 +3,9 @@ import http from 'http';
 import { Server as WsServer } from 'ws';
 import { CronManager } from './cron-handler';
 import { LockedData } from './locked-data';
+import { MotiaEventManager } from './step-handlers';
 import { ApiRouteConfig, EventManager, InternalStateManager, Step } from './types';
+import { Printer } from './printer';
 export type MotiaServer = {
     app: Express;
     server: http.Server;
@@ -12,9 +14,11 @@ export type MotiaServer = {
     removeRoute: (step: Step<ApiRouteConfig>) => void;
     addRoute: (step: Step<ApiRouteConfig>) => void;
     cronManager: CronManager;
+    motiaEventManager: MotiaEventManager;
 };
 type MotiaServerConfig = {
     isVerbose: boolean;
+    printer?: Printer;
 };
-export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: InternalStateManager, config: MotiaServerConfig) => Promise<MotiaServer>;
+export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: InternalStateManager, config: MotiaServerConfig) => MotiaServer;
 export {};

package/dist/src/server.js

@@ -16,14 +16,17 @@ const flows_config_endpoint_1 = require("./flows-config-endpoint");
 const flows_endpoint_1 = require("./flows-endpoint");
 const generate_trace_id_1 = require("./generate-trace-id");
 const guards_1 = require("./guards");
-const logger_1 = require("./logger");
 const logger_factory_1 = require("./logger-factory");
+const tracer_1 = require("./observability/tracer");
 const socket_server_1 = require("./socket-server");
+const step_handlers_1 = require("./step-handlers");
 const steps_1 = require("./steps");
 const api_endpoints_1 = require("./streams/api-endpoints");
 const logs_stream_1 = require("./streams/logs-stream");
-const createServer = async (lockedData, eventManager, state, config) => {
-    const printer = lockedData.printer;
+const logger_1 = require("./logger");
+const printer_1 = require("./printer");
+const createServer = (lockedData, eventManager, state, config) => {
+    const printer = config.printer ?? new printer_1.Printer(process.cwd());
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
     const { pushEvent, socketServer } = (0, socket_server_1.createSocketServer)({
@@ -33,7 +36,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
             const stream = streams[streamName];
             if (stream) {
                 const result = await stream().get(groupId, id);
-                delete result.__motia; // deleting because we don't need it in the socket
+                delete result?.__motia; // deleting because we don't need it in the socket
                 return result;
             }
         },
@@ -105,33 +108,26 @@ const createServer = async (lockedData, eventManager, state, config) => {
         },
     })();
     const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
-    const loggerFactory = new logger_factory_1.LoggerFactory(config.isVerbose, logStream);
-    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, loggerFactory);
+    const loggerFactory = new logger_factory_1.BaseLoggerFactory(config.isVerbose, logStream);
+    const tracerFactory = (0, tracer_1.createTracerFactory)(lockedData);
+    const motia = { loggerFactory, eventManager, state, lockedData, printer, tracerFactory };
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(motia);
+    const motiaEventManager = (0, step_handlers_1.createStepHandlers)(motia);
     const asyncHandler = (step) => {
         return async (req, res) => {
             const traceId = (0, generate_trace_id_1.generateTraceId)();
             const { name: stepName, flows } = step.config;
             const logger = loggerFactory.create({ traceId, flows, stepName });
+            const tracer = motia.tracerFactory.createTracer(traceId, step, logger);
             logger.debug('[API] Received request, processing step', { path: req.path });
-            const request = {
+            const data = {
                 body: req.body,
                 headers: req.headers,
                 pathParams: req.params,
                 queryParams: req.query,
             };
             try {
-                const data = request;
-                const result = await (0, call_step_file_1.callStepFile)({
-                    contextInFirstArg: false,
-                    lockedData,
-                    data,
-                    step,
-                    printer,
-                    logger,
-                    eventManager,
-                    state,
-                    traceId,
-                });
+                const result = await (0, call_step_file_1.callStepFile)({ data, step, logger, tracer, traceId }, motia);
                 if (!result) {
                     console.log('no result');
                     res.status(500).json({ error: 'Internal server error' });
@@ -194,8 +190,8 @@ const createServer = async (lockedData, eventManager, state, config) => {
     app.use((0, cors_1.default)());
     app.use(router);
     (0, api_endpoints_1.apiEndpoints)(lockedData);
-    (0, flows_endpoint_1.flowsEndpoint)(lockedData, app);
-    (0, flows_config_endpoint_1.flowsConfigEndpoint)(app, process.cwd());
+    (0, flows_endpoint_1.flowsEndpoint)(lockedData);
+    (0, flows_config_endpoint_1.flowsConfigEndpoint)(app, process.cwd(), lockedData);
     (0, analytics_endpoint_1.analyticsEndpoint)(app, process.cwd());
     server.on('error', (error) => {
         console.error('Server error:', error);
@@ -204,6 +200,6 @@ const createServer = async (lockedData, eventManager, state, config) => {
         cronManager.close();
         socketServer.close();
     };
-    return { app, server, socketServer, close, removeRoute, addRoute, cronManager };
+    return { app, server, socketServer, close, removeRoute, addRoute, cronManager, motiaEventManager };
 };
 exports.createServer = createServer;

package/dist/src/state/adapters/default-state-adapter.js

@@ -42,6 +42,7 @@ const path = __importStar(require("path"));
 class FileStateAdapter {
     constructor(config) {
         this.filePath = path.join(config.filePath, 'motia.state.json');
+        this.init();
     }
     init() {
         const dir = this.filePath.replace('motia.state.json', '');

package/dist/src/state/adapters/memory-state-adapter.d.ts

@@ -1,7 +1,7 @@
 import { StateAdapter } from '../state-adapter';
 export declare class MemoryStateAdapter implements StateAdapter {
     private state;
-    init(): Promise<void>;
+    constructor();
     getGroup<T>(groupId: string): Promise<T[]>;
     get<T>(traceId: string, key: string): Promise<T | null>;
     set<T>(traceId: string, key: string, value: T): Promise<T>;

package/dist/src/state/adapters/memory-state-adapter.js

@@ -4,8 +4,6 @@ exports.MemoryStateAdapter = void 0;
 class MemoryStateAdapter {
     constructor() {
         this.state = {};
-    }
-    async init() {
         this.state = {};
     }
     async getGroup(groupId) {

package/dist/src/step-handlers.d.ts

@@ -1,7 +1,7 @@
-import { EventConfig, EventManager, InternalStateManager, Step } from './types';
-import { LockedData } from './locked-data';
+import { Motia } from './motia';
+import { EventConfig, Step } from './types';
 export type MotiaEventManager = {
     createHandler: (step: Step<EventConfig>) => void;
     removeHandler: (step: Step<EventConfig>) => void;
 };
-export declare const createStepHandlers: (lockedData: LockedData, eventManager: EventManager, state: InternalStateManager) => MotiaEventManager;
+export declare const createStepHandlers: (motia: Motia) => MotiaEventManager;

package/dist/src/step-handlers.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStepHandlers = void 0;
-const logger_1 = require("./logger");
 const call_step_file_1 = require("./call-step-file");
-const createStepHandlers = (lockedData, eventManager, state) => {
-    const eventSteps = lockedData.eventSteps();
-    const printer = lockedData.printer;
+const logger_1 = require("./logger");
+const createStepHandlers = (motia) => {
+    const eventSteps = motia.lockedData.eventSteps();
     logger_1.globalLogger.debug(`[step handler] creating step handlers for ${eventSteps.length} steps`);
     const removeLogger = (event) => {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { logger, ...rest } = event;
+        const { logger, tracer, ...rest } = event;
         return rest;
     };
     const createHandler = (step) => {
@@ -17,25 +16,17 @@ const createStepHandlers = (lockedData, eventManager, state) => {
         const { subscribes, name } = config;
         logger_1.globalLogger.debug('[step handler] establishing step subscriptions', { filePath, step: step.config.name });
         subscribes.forEach((subscribe) => {
-            eventManager.subscribe({
+            motia.eventManager.subscribe({
                 filePath,
                 event: subscribe,
                 handlerName: step.config.name,
                 handler: async (event) => {
-                    const { logger, data, traceId } = event;
+                    const { data, traceId } = event;
+                    const logger = event.logger.child(step);
+                    const tracer = event.tracer.child(step, logger);
                     logger_1.globalLogger.debug('[step handler] received event', { event: removeLogger(event), step: name });
                     try {
-                        await (0, call_step_file_1.callStepFile)({
-                            contextInFirstArg: false,
-                            step,
-                            printer,
-                            eventManager,
-                            state,
-                            lockedData,
-                            data,
-                            traceId,
-                            logger,
-                        });
+                        await (0, call_step_file_1.callStepFile)({ step, data, traceId, tracer, logger }, motia);
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     }
                     catch (error) {
@@ -50,7 +41,7 @@ const createStepHandlers = (lockedData, eventManager, state) => {
         const { config, filePath } = step;
         const { subscribes } = config;
         subscribes.forEach((subscribe) => {
-            eventManager.unsubscribe({ filePath, event: subscribe });
+            motia.eventManager.unsubscribe({ filePath, event: subscribe });
         });
     };
     eventSteps.forEach(createHandler);

package/dist/src/streams/flows-config-stream.d.ts

@@ -0,0 +1,13 @@
+import { StreamAdapter } from './adapters/stream-adapter';
+import { FlowConfig } from '../types/flows-config-types';
+export declare class FlowsConfigStream extends StreamAdapter<FlowConfig> {
+    private readonly configPath;
+    private config;
+    constructor(configPath: string);
+    private getConfig;
+    private setConfig;
+    get(_: string, id: string): Promise<FlowConfig | null>;
+    delete(_: string): Promise<null>;
+    set(_: string, id: string, data: FlowConfig): Promise<FlowConfig>;
+    getGroup(): Promise<FlowConfig[]>;
+}

package/dist/src/streams/flows-config-stream.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowsConfigStream = void 0;
+const stream_adapter_1 = require("./adapters/stream-adapter");
+const fs_1 = __importDefault(require("fs"));
+class FlowsConfigStream extends stream_adapter_1.StreamAdapter {
+    constructor(configPath) {
+        super();
+        this.configPath = configPath;
+        this.config = [];
+    }
+    getConfig() {
+        if (this.config.length === 0) {
+            if (fs_1.default.existsSync(this.configPath)) {
+                this.config = JSON.parse(fs_1.default.readFileSync(this.configPath, 'utf8') || '[]');
+                if (!Array.isArray(this.config)) {
+                    this.config = [];
+                    this.setConfig(this.config);
+                }
+            }
+        }
+        return this.config;
+    }
+    setConfig(config) {
+        this.config = config;
+        fs_1.default.writeFileSync(this.configPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    async get(_, id) {
+        const allFlowsConfig = this.getConfig();
+        return allFlowsConfig.find((flow) => flow.id === id) || null;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async delete(_) {
+        return null;
+    }
+    async set(_, id, data) {
+        const existingConfig = this.getConfig();
+        const updatedConfig = existingConfig.filter((item) => item.id !== id);
+        updatedConfig.push(data);
+        this.setConfig(updatedConfig);
+        return data;
+    }
+    async getGroup() {
+        return this.getConfig();
+    }
+}
+exports.FlowsConfigStream = FlowsConfigStream;

package/dist/src/streams/flows-stream.d.ts

@@ -1,14 +1,11 @@
 import { LockedData } from '../locked-data';
 import { StreamAdapter } from './adapters/stream-adapter';
-export type Flow = {
-    id: string;
-    name: string;
-};
-export declare class FlowsStream extends StreamAdapter<Flow> {
+import { FlowResponse } from '../types/flows-types';
+export declare class FlowsStream extends StreamAdapter<FlowResponse> {
     private readonly lockedData;
     constructor(lockedData: LockedData);
-    get(id: string): Promise<Flow | null>;
-    delete(id: string): Promise<Flow | null>;
-    set(_: string, __: string, data: Flow): Promise<Flow>;
-    getGroup(): Promise<Flow[]>;
+    get(_: string, id: string): Promise<FlowResponse | null>;
+    delete(_: string): Promise<FlowResponse | null>;
+    set(_: string, __: string, data: FlowResponse): Promise<FlowResponse>;
+    getGroup(): Promise<FlowResponse[]>;
 }

package/dist/src/streams/flows-stream.js

@@ -2,18 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowsStream = void 0;
 const stream_adapter_1 = require("./adapters/stream-adapter");
+const flows_helper_1 = require("../helper/flows-helper");
 class FlowsStream extends stream_adapter_1.StreamAdapter {
     constructor(lockedData) {
         super();
         this.lockedData = lockedData;
     }
-    async get(id) {
-        return (Object.entries(this.lockedData.flows)
-            .map(([id, flow]) => ({ id, name: flow.name }))
-            .find((flow) => flow.id === id) ?? null);
+    async get(_, id) {
+        const flow = this.lockedData.flows[id];
+        if (!flow) {
+            return null;
+        }
+        return (0, flows_helper_1.generateFlow)(id, flow.steps);
     }
-    async delete(id) {
-        return { id, name: id };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async delete(_) {
+        return null;
     }
     async set(_, __, data) {
         return data;
@@ -23,7 +27,7 @@ class FlowsStream extends stream_adapter_1.StreamAdapter {
          * Get list should receive a groupId argument but that's irrelevant for this stream
          * since we only have one group of flows.
          */
-        return Object.entries(this.lockedData.flows).map(([id, flow]) => ({ id, name: flow.name }));
+        return Object.entries(this.lockedData.flows).map(([id, flow]) => (0, flows_helper_1.generateFlow)(id, flow.steps));
     }
 }
 exports.FlowsStream = FlowsStream;

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

@@ -0,0 +1,9 @@
+export interface FlowConfig {
+    id: string;
+    config: {
+        [filePath: string]: {
+            x: number;
+            y: number;
+        };
+    };
+}

package/dist/src/types/flows-config-types.js

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

package/dist/src/types/flows-types.d.ts

@@ -0,0 +1,37 @@
+import { Emit } from '../types';
+export type FlowListResponse = {
+    id: string;
+    name: string;
+};
+export type EdgeData = {
+    variant: 'event' | 'virtual';
+    topic: string;
+    label?: string;
+    labelVariant?: 'default' | 'conditional';
+};
+export type FlowEdge = {
+    id: string;
+    source: string;
+    target: string;
+    data: EdgeData;
+};
+export type FlowStepResponse = {
+    id: string;
+    name: string;
+    type: 'event' | 'api' | 'noop' | 'cron';
+    description?: string;
+    subscribes?: string[];
+    emits: Emit[];
+    virtualEmits?: Emit[];
+    action?: 'webhook';
+    webhookUrl?: string;
+    bodySchema?: unknown;
+    language?: string;
+    nodeComponentPath?: string;
+    filePath?: string;
+    cronExpression?: string;
+};
+export type FlowResponse = FlowListResponse & {
+    steps: FlowStepResponse[];
+    edges: FlowEdge[];
+};

package/dist/src/types/flows-types.js

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