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

package/dist/src/streams/redis-logs-stream.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLogsStream = void 0;
+const uuid_1 = require("uuid");
+const stream_adapter_interface_1 = require("../adapters/interfaces/stream-adapter.interface");
+const LOG_TTL_SECONDS = 3 * 24 * 60 * 60;
+class RedisLogsStream extends stream_adapter_interface_1.StreamAdapter {
+    constructor(client) {
+        super('__motia.logs');
+        this.keyPrefix = 'motia:logs:';
+        this.client = client;
+    }
+    makeLogKey(groupId, id) {
+        return `${this.keyPrefix}${groupId}:${id}`;
+    }
+    makeChannelKey(channel) {
+        return `${this.keyPrefix}events:${channel.groupId}:${channel.id}`;
+    }
+    makeLogId() {
+        return `${Date.now()}-${(0, uuid_1.v4)()}`;
+    }
+    async scanKeys(pattern) {
+        const keys = [];
+        let cursor = '0';
+        do {
+            const result = await this.client.scan(cursor.toString(), {
+                MATCH: pattern,
+                COUNT: 100,
+            });
+            cursor = result.cursor;
+            keys.push(...result.keys);
+        } while (String(cursor) !== '0');
+        return keys;
+    }
+    async get(groupId, id) {
+        const key = this.makeLogKey(groupId, id);
+        const value = await this.client.get(key);
+        return value ? JSON.parse(value) : null;
+    }
+    async set(groupId, id, data) {
+        const logId = id || this.makeLogId();
+        const key = this.makeLogKey(groupId, logId);
+        const logData = { ...data, id: logId };
+        const item = { ...logData, id: logId };
+        const itemJson = JSON.stringify(item);
+        await Promise.all([
+            this.client.set(key, itemJson),
+            this.client.expire(key, LOG_TTL_SECONDS),
+            this.send({ groupId, id: logId }, { type: 'log', data: item }),
+        ]);
+        return item;
+    }
+    async delete(groupId, id) {
+        const key = this.makeLogKey(groupId, id);
+        const value = await this.client.get(key);
+        if (!value)
+            return null;
+        const item = JSON.parse(value);
+        await Promise.all([this.client.del(key), this.send({ groupId, id }, { type: 'delete', data: item })]);
+        return item;
+    }
+    async getGroup(groupId) {
+        const pattern = `${this.keyPrefix}${groupId}:*`;
+        const keys = await this.scanKeys(pattern);
+        if (keys.length === 0)
+            return [];
+        const values = await this.client.mGet(keys);
+        const logs = values.filter((v) => v !== null).map((v) => JSON.parse(v));
+        const sortDesc = (a, b) => a.time - b.time;
+        return logs.sort(sortDesc);
+    }
+    async send(channel, event) {
+        const channelKey = this.makeChannelKey(channel);
+        await this.client.publish(channelKey, JSON.stringify(event));
+    }
+    async clear(groupId) {
+        const pattern = `${this.keyPrefix}${groupId}:*`;
+        const keys = await this.scanKeys(pattern);
+        if (keys.length === 0)
+            return;
+        await this.client.del(keys);
+    }
+}
+exports.RedisLogsStream = RedisLogsStream;

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

@@ -0,0 +1,3 @@
+import type { MotiaStream } from '../types-stream';
+export type StreamFactory<TData> = () => MotiaStream<TData>;
+//# sourceMappingURL=stream-factory.d.ts.map

package/dist/src/streams/stream-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-factory.d.ts","sourceRoot":"","sources":["../../../src/streams/stream-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAElD,MAAM,MAAM,aAAa,CAAC,KAAK,IAAI,MAAM,WAAW,CAAC,KAAK,CAAC,CAAA"}

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

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

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

@@ -0,0 +1,45 @@
+import type { Express } from 'express';
+import type { z } from 'zod';
+import type { CronAdapter } from '../adapters/interfaces/cron-adapter.interface';
+import type { EventAdapter } from '../adapters/interfaces/event-adapter.interface';
+import type { StateAdapter } from '../adapters/interfaces/state-adapter.interface';
+import type { StreamAdapterManager } from '../adapters/interfaces/stream-adapter-manager.interface';
+import type { MotiaPluginContext } from '../motia';
+import type { JsonSchema } from './schema.types';
+export type WorkbenchPlugin = {
+    packageName: string;
+    componentName?: string;
+    label?: string;
+    labelIcon?: string;
+    position?: 'bottom' | 'top';
+    cssImports?: string[];
+    props?: Record<string, any>;
+};
+export type MotiaPlugin = {
+    workbench: WorkbenchPlugin[];
+    dirname?: string;
+    steps?: string[];
+    onShutdown?: () => Promise<void>;
+};
+export type MotiaPluginBuilder = (motia: MotiaPluginContext) => MotiaPlugin;
+export type AdapterConfig = {
+    state?: StateAdapter;
+    streams?: StreamAdapterManager;
+    events?: EventAdapter;
+    cron?: CronAdapter;
+};
+export type StreamAuthRequest = {
+    headers: Record<string, string | string[] | undefined>;
+    url?: string;
+};
+export type StreamAuthConfig<TSchema extends z.ZodTypeAny = z.ZodTypeAny> = {
+    contextSchema: JsonSchema;
+    authenticate: (request: StreamAuthRequest) => Promise<z.infer<TSchema> | null> | (z.infer<TSchema> | null);
+};
+export type Config = {
+    app?: (app: Express) => void;
+    plugins?: MotiaPluginBuilder[];
+    adapters?: AdapterConfig;
+    streamAuth?: StreamAuthConfig;
+};
+//# sourceMappingURL=app-config-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"app-config-types.d.ts","sourceRoot":"","sources":["../../../src/types/app-config-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAA;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAA;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAA;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yDAAyD,CAAA;AACnG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAA;IAC3B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IAErB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,eAAe,EAAE,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,WAAW,CAAA;AAE3E,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB,OAAO,CAAC,EAAE,oBAAoB,CAAA;IAC9B,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,IAAI,CAAC,EAAE,WAAW,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAA;IACtD,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,gBAAgB,CAAC,OAAO,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,IAAI;IAC1E,aAAa,EAAE,UAAU,CAAA;IACzB,YAAY,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;CAC3G,CAAA;AAED,MAAM,MAAM,MAAM,GAAG;IACnB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IAC5B,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,UAAU,CAAC,EAAE,gBAAgB,CAAA;CAC9B,CAAA"}

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

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

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

@@ -0,0 +1,10 @@
+export interface FlowConfig {
+    id: string;
+    config: {
+        [filePath: string]: {
+            x: number;
+            y: number;
+        };
+    };
+}
+//# sourceMappingURL=flows-config-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flows-config-types.d.ts","sourceRoot":"","sources":["../../../src/types/flows-config-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE;QACN,CAAC,QAAQ,EAAE,MAAM,GAAG;YAClB,CAAC,EAAE,MAAM,CAAA;YACT,CAAC,EAAE,MAAM,CAAA;SACV,CAAA;KACF,CAAA;CACF"}

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,39 @@
+import type { 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[];
+    virtualSubscribes?: string[];
+    action?: 'webhook';
+    webhookUrl?: string;
+    bodySchema?: unknown;
+    language?: string;
+    nodeComponentPath?: string;
+    filePath?: string;
+    cronExpression?: string;
+};
+export type FlowResponse = FlowListResponse & {
+    steps: FlowStepResponse[];
+    edges: FlowEdge[];
+};
+//# sourceMappingURL=flows-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flows-types.d.ts","sourceRoot":"","sources":["../../../src/types/flows-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAEpC,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3D,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,SAAS,GAAG,aAAa,CAAA;CACzC,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAA;IACvC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,YAAY,CAAC,EAAE,IAAI,EAAE,CAAA;IACrB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG;IAC5C,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,KAAK,EAAE,QAAQ,EAAE,CAAA;CAClB,CAAA"}

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

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

package/dist/src/types/generate-type-from-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JSONSchema } from 'zod/v4/core';
+export declare const generateTypeFromSchema: (schema: JSONSchema.BaseSchema) => string;
+//# sourceMappingURL=generate-type-from-schema.d.ts.map

package/dist/src/types/generate-type-from-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-type-from-schema.d.ts","sourceRoot":"","sources":["../../../src/types/generate-type-from-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,sBAAsB,GAAI,QAAQ,UAAU,CAAC,UAAU,KAAG,MAgDtE,CAAA"}

package/dist/src/types/generate-type-from-schema.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypeFromSchema = void 0;
+const schema_types_1 = require("./schema.types");
+const generateTypeFromSchema = (schema) => {
+    if (!schema) {
+        return 'unknown';
+    }
+    if ((0, schema_types_1.isAnyOf)(schema)) {
+        const types = schema.anyOf.map(exports.generateTypeFromSchema);
+        return types.join(' | ');
+    }
+    if (schema.type === 'array') {
+        const itemType = schema.items ? (0, exports.generateTypeFromSchema)(schema.items) : 'unknown';
+        return `Array<${itemType}>`;
+    }
+    if (schema.type === 'object' && schema.properties) {
+        const props = Object.entries(schema.properties).map(([key, prop]) => {
+            const isRequired = schema.required?.includes(key);
+            const propType = (0, exports.generateTypeFromSchema)(prop);
+            return `${key}${isRequired ? '' : '?'}: ${propType}`;
+        });
+        return props.length > 0 ? `{ ${props.join('; ')} }` : '{}';
+    }
+    else if (schema.type === 'object' && schema.additionalProperties) {
+        const propType = (0, exports.generateTypeFromSchema)(schema.additionalProperties);
+        return `Record<string, ${propType}>`;
+    }
+    if (schema.type === 'string') {
+        if (schema.format === 'binary') {
+            return 'Buffer';
+        }
+        return schema.enum && schema.enum.length > 0 // must have at least one enum value
+            ? schema.enum.map((value) => `'${value}'`).join(' | ')
+            : 'string';
+    }
+    if (typeof schema === 'object' && schema !== null && 'not' in schema) {
+        return 'undefined';
+    }
+    switch (schema.type) {
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        default:
+            return 'unknown';
+    }
+};
+exports.generateTypeFromSchema = generateTypeFromSchema;

package/dist/src/types/generate-types-from-response.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from './schema.types';
+export declare const generateTypesFromResponse: (record: Record<number, JsonSchema>) => string;
+//# sourceMappingURL=generate-types-from-response.d.ts.map

package/dist/src/types/generate-types-from-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types-from-response.d.ts","sourceRoot":"","sources":["../../../src/types/generate-types-from-response.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,eAAO,MAAM,yBAAyB,GAAI,QAAQ,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,KAAG,MAO9E,CAAA"}

package/dist/src/types/generate-types-from-response.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesFromResponse = void 0;
+const generate_type_from_schema_1 = require("./generate-type-from-schema");
+const generateTypesFromResponse = (record) => {
+    return Object.entries(record)
+        .map(([status, schema]) => {
+        const schemaType = (0, generate_type_from_schema_1.generateTypeFromSchema)(schema);
+        return `ApiResponse<${status}, ${schemaType}>`;
+    })
+        .join(' | ');
+};
+exports.generateTypesFromResponse = generateTypesFromResponse;

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

@@ -0,0 +1,13 @@
+import type { Printer } from '../printer';
+import type { Step } from '../types';
+import type { Stream } from '../types-stream';
+type HandlersMap = Record<string, {
+    type: string;
+    generics: string[];
+}>;
+type StreamsMap = Record<string, string>;
+export declare const generateTypesString: (handlers: HandlersMap, streams: StreamsMap, streamAuthContextType?: string) => string;
+export declare const generateTypesFromSteps: (steps: Step[], printer: Printer) => HandlersMap;
+export declare const generateTypesFromStreams: (streams: Record<string, Stream>) => StreamsMap;
+export {};
+//# sourceMappingURL=generate-types.d.ts.map

package/dist/src/types/generate-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types.d.ts","sourceRoot":"","sources":["../../../src/types/generate-types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEzC,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAM7C,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAA;AACvE,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAExC,eAAO,MAAM,mBAAmB,GAC9B,UAAU,WAAW,EACrB,SAAS,UAAU,EACnB,wBAAwB,MAAM,KAC7B,MAyBF,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,OAAO,IAAI,EAAE,EAAE,SAAS,OAAO,KAAG,WAwFxE,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,UAO1E,CAAA"}

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesFromStreams = exports.generateTypesFromSteps = exports.generateTypesString = void 0;
+const guards_1 = require("../guards");
+const schema_utils_1 = require("../schema-utils");
+const generate_type_from_schema_1 = require("./generate-type-from-schema");
+const generate_types_from_response_1 = require("./generate-types-from-response");
+const merge_schemas_1 = require("./merge-schemas");
+const generateTypesString = (handlers, streams, streamAuthContextType) => {
+    return `/**
+ * Automatically generated types for motia
+ * Do NOT edit this file manually.
+ * 
+ * Consider adding this file to .prettierignore and eslint ignore.
+ */
+import { EventHandler, ApiRouteHandler, ApiResponse, MotiaStream, CronHandler } from 'motia'
+
+declare module 'motia' {
+  interface FlowContextStateStreams {
+    ${Object.entries(streams)
+        .map(([key, value]) => `'${key}': MotiaStream<${value}>`)
+        .join('\n    ')
+        .trim()}
+  }
+
+  interface Handlers {
+    ${Object.entries(handlers)
+        .map(([key, { type, generics }]) => `'${key}': ${type}<${generics.join(', ')}>`)
+        .join('\n    ')
+        .trim()}
+  }
+    ${streamAuthContextType ? `interface StreamAuthContext ${streamAuthContextType}` : ''}
+}`;
+};
+exports.generateTypesString = generateTypesString;
+const generateTypesFromSteps = (steps, printer) => {
+    const handlers = {};
+    const topics = {};
+    const topicsSchemas = {};
+    const topicsSteps = {};
+    const topicIsFifo = {};
+    for (const step of steps) {
+        if ((0, guards_1.isEventStep)(step)) {
+            if (!step.config.input) {
+                for (const topic of step.config.subscribes) {
+                    if (!topics[topic]) {
+                        topics[topic] = 'never';
+                    }
+                }
+                continue;
+            }
+            for (const topic of step.config.subscribes) {
+                const existingSchema = topicsSchemas[topic];
+                topicsSteps[topic] = topicsSteps[topic] ?? [];
+                topicsSteps[topic].push(step);
+                const queueType = step.config.infrastructure?.queue?.type;
+                if (queueType === 'fifo') {
+                    topicIsFifo[topic] = true;
+                }
+                try {
+                    const input = step.config.input;
+                    const schema = existingSchema
+                        ? (0, merge_schemas_1.mergeSchemas)(existingSchema, input)
+                        : ((0, schema_utils_1.schemaToJsonSchema)(input) ?? input);
+                    topics[topic] = (0, generate_type_from_schema_1.generateTypeFromSchema)(schema);
+                    topicsSchemas[topic] = schema;
+                }
+                catch (error) {
+                    printer.printInvalidSchema(topic, topicsSteps[topic]);
+                    topics[topic] = 'never';
+                }
+            }
+        }
+    }
+    const generateEmitData = (emit, step) => {
+        const emits = emit
+            .reduce((acc, emit) => {
+            const topic = typeof emit === 'string' ? emit : emit.topic;
+            const topicType = topics[topic];
+            if (topicType) {
+                const isFifo = topicIsFifo[topic];
+                if (isFifo) {
+                    acc.push(`{ topic: '${topic.replace(/'/g, "\\'")}'; data: ${topicType}; messageGroupId: string }`);
+                }
+                else {
+                    acc.push(`{ topic: '${topic.replace(/'/g, "\\'")}'; data: ${topicType} }`);
+                }
+            }
+            else {
+                printer.printInvalidEmitConfiguration(step, topic);
+            }
+            return acc;
+        }, [])
+            .join(' | ');
+        return emits.length === 0 ? 'never' : emits;
+    };
+    for (const step of steps) {
+        const emits = 'emits' in step.config ? generateEmitData(step.config.emits, step) : 'never';
+        if ((0, guards_1.isEventStep)(step)) {
+            const input = step.config.input ? (0, generate_type_from_schema_1.generateTypeFromSchema)(step.config.input) : 'never';
+            handlers[step.config.name] = { type: 'EventHandler', generics: [input, emits] };
+        }
+        else if ((0, guards_1.isApiStep)(step)) {
+            const input = step.config.bodySchema
+                ? (0, generate_type_from_schema_1.generateTypeFromSchema)(step.config.bodySchema)
+                : 'Record<string, unknown>';
+            const result = step.config.responseSchema
+                ? (0, generate_types_from_response_1.generateTypesFromResponse)(step.config.responseSchema)
+                : 'unknown';
+            handlers[step.config.name] = { type: 'ApiRouteHandler', generics: [input, result, emits] };
+        }
+        else if ((0, guards_1.isCronStep)(step)) {
+            handlers[step.config.name] = { type: 'CronHandler', generics: [emits] };
+        }
+    }
+    return handlers;
+};
+exports.generateTypesFromSteps = generateTypesFromSteps;
+const generateTypesFromStreams = (streams) => {
+    return Object.entries(streams).reduce((acc, [key, stream]) => {
+        if (!stream.hidden) {
+            acc[key] = (0, generate_type_from_schema_1.generateTypeFromSchema)(stream.config.schema);
+        }
+        return acc;
+    }, {});
+};
+exports.generateTypesFromStreams = generateTypesFromStreams;

package/dist/src/types/merge-schemas.d.ts

@@ -0,0 +1,5 @@
+import { type SchemaInput } from '../schema-utils';
+import { type JsonSchema } from './schema.types';
+export declare const isCompatible: (schema: JsonSchema, otherSchema: JsonSchema) => boolean;
+export declare const mergeSchemas: (schema: SchemaInput, otherSchema: SchemaInput) => JsonSchema;
+//# sourceMappingURL=merge-schemas.d.ts.map

package/dist/src/types/merge-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-schemas.d.ts","sourceRoot":"","sources":["../../../src/types/merge-schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,WAAW,EAAsB,MAAM,iBAAiB,CAAA;AACnF,OAAO,EAAW,KAAK,UAAU,EAAmB,MAAM,gBAAgB,CAAA;AAM1E,eAAO,MAAM,YAAY,GAAI,QAAQ,UAAU,EAAE,aAAa,UAAU,KAAG,OAqD1E,CAAA;AAUD,eAAO,MAAM,YAAY,GAAI,QAAQ,WAAW,EAAE,aAAa,WAAW,KAAG,UA4F5E,CAAA"}

package/dist/src/types/merge-schemas.js

@@ -0,0 +1,183 @@
+"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.mergeSchemas = exports.isCompatible = void 0;
+const z = __importStar(require("zod"));
+const schema_utils_1 = require("../schema-utils");
+const schema_types_1 = require("./schema.types");
+const isJsonSchema = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value !== 'boolean';
+};
+const isCompatible = (schema, otherSchema) => {
+    if ((0, schema_types_1.isAnyOf)(schema)) {
+        return schema.anyOf.every((item) => (0, exports.isCompatible)(item, otherSchema));
+    }
+    else if ((0, schema_types_1.isAnyOf)(otherSchema)) {
+        return otherSchema.anyOf.every((item) => (0, exports.isCompatible)(schema, item));
+    }
+    if (schema.type !== otherSchema.type) {
+        return false;
+    }
+    if (schema.type === 'array' && otherSchema.type === 'array') {
+        if (!schema.items || !otherSchema.items) {
+            return schema.items === otherSchema.items;
+        }
+        if (Array.isArray(schema.items) || Array.isArray(otherSchema.items)) {
+            return false;
+        }
+        if (isJsonSchema(schema.items) && isJsonSchema(otherSchema.items)) {
+            return (0, exports.isCompatible)(schema.items, otherSchema.items);
+        }
+        return schema.items === otherSchema.items;
+    }
+    if (schema.type === 'object' && otherSchema.type === 'object') {
+        const schemaProps = schema.properties;
+        const otherSchemaProps = otherSchema.properties;
+        if (!schemaProps || !otherSchemaProps) {
+            return schemaProps === otherSchemaProps;
+        }
+        const keysFromSchema = Object.keys(schemaProps);
+        const keysFromOtherSchema = Object.keys(otherSchemaProps);
+        const commonKeys = keysFromSchema.filter((key) => keysFromOtherSchema.includes(key));
+        if (schema.required?.some((key) => !keysFromOtherSchema.includes(key))) {
+            return false;
+        }
+        else if (otherSchema.required?.some((key) => !keysFromSchema.includes(key))) {
+            return false;
+        }
+        if (commonKeys.length > 0) {
+            return commonKeys.every((key) => {
+                const prop1 = schemaProps[key];
+                const prop2 = otherSchemaProps[key];
+                if (isJsonSchema(prop1) && isJsonSchema(prop2)) {
+                    return (0, exports.isCompatible)(prop1, prop2);
+                }
+                return prop1 === prop2;
+            });
+        }
+    }
+    return true;
+};
+exports.isCompatible = isCompatible;
+const mergeZodSchemas = (schema, otherSchema) => {
+    try {
+        return z.intersection(schema, otherSchema);
+    }
+    catch (error) {
+        throw new schema_types_1.JsonSchemaError(`Cannot merge Zod schemas: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+const mergeSchemas = (schema, otherSchema) => {
+    if ((0, schema_utils_1.isZodSchema)(schema) && (0, schema_utils_1.isZodSchema)(otherSchema)) {
+        const mergedZodSchema = mergeZodSchemas(schema, otherSchema);
+        const jsonSchema = (0, schema_utils_1.schemaToJsonSchema)(mergedZodSchema);
+        if (!jsonSchema) {
+            throw new schema_types_1.JsonSchemaError('Failed to convert merged Zod schema to JSON Schema');
+        }
+        return jsonSchema;
+    }
+    const schemaJsonResult = (0, schema_utils_1.schemaToJsonSchema)(schema);
+    const otherSchemaJsonResult = (0, schema_utils_1.schemaToJsonSchema)(otherSchema);
+    if (!schemaJsonResult || !otherSchemaJsonResult) {
+        throw new schema_types_1.JsonSchemaError('Cannot merge schemas: failed to convert to JSON Schema');
+    }
+    const schemaJson = schemaJsonResult;
+    const otherSchemaJson = otherSchemaJsonResult;
+    if (!(0, exports.isCompatible)(schemaJson, otherSchemaJson)) {
+        throw new schema_types_1.JsonSchemaError('Cannot merge schemas of different types');
+    }
+    if ((0, schema_types_1.isAnyOf)(schemaJson)) {
+        return {
+            anyOf: schemaJson.anyOf.map((item) => (0, exports.mergeSchemas)(item, otherSchemaJson)),
+        };
+    }
+    else if ((0, schema_types_1.isAnyOf)(otherSchemaJson)) {
+        return {
+            anyOf: otherSchemaJson.anyOf.map((item) => (0, exports.mergeSchemas)(schemaJson, item)),
+        };
+    }
+    if (schemaJson.type === 'object' && otherSchemaJson.type === 'object') {
+        const schemaProps = schemaJson.properties;
+        const otherSchemaProps = otherSchemaJson.properties;
+        if (!schemaProps || !otherSchemaProps) {
+            throw new schema_types_1.JsonSchemaError('Cannot merge object schemas without properties');
+        }
+        const mergedProperties = { ...schemaProps, ...otherSchemaProps };
+        const otherSchemaKeys = Object.keys(otherSchemaProps).reduce((acc, key) => {
+            acc[key] = true;
+            return acc;
+        }, {});
+        for (const key in schemaProps) {
+            if (otherSchemaKeys[key]) {
+                const prop1 = schemaProps[key];
+                const prop2 = otherSchemaProps[key];
+                if (isJsonSchema(prop1) && isJsonSchema(prop2)) {
+                    mergedProperties[key] = (0, exports.mergeSchemas)(prop1, prop2);
+                }
+                else {
+                    mergedProperties[key] = prop2;
+                }
+            }
+        }
+        const schemaRequired = schemaJson.required;
+        const otherSchemaRequired = otherSchemaJson.required;
+        const mergedRequired = new Set([...(schemaRequired ?? []), ...(otherSchemaRequired ?? [])]);
+        return {
+            type: 'object',
+            properties: mergedProperties,
+            required: Array.from(mergedRequired),
+        };
+    }
+    if (schemaJson.type === 'array' && otherSchemaJson.type === 'array') {
+        if (!schemaJson.items || !otherSchemaJson.items) {
+            throw new schema_types_1.JsonSchemaError('Cannot merge array schemas without items');
+        }
+        if (Array.isArray(schemaJson.items) || Array.isArray(otherSchemaJson.items)) {
+            throw new schema_types_1.JsonSchemaError('Cannot merge array schemas with array items');
+        }
+        if (!isJsonSchema(schemaJson.items) || !isJsonSchema(otherSchemaJson.items)) {
+            throw new schema_types_1.JsonSchemaError('Cannot merge array schemas with non-object items');
+        }
+        return {
+            type: 'array',
+            items: (0, exports.mergeSchemas)(schemaJson.items, otherSchemaJson.items),
+        };
+    }
+    return {
+        type: schemaJson.type,
+        description: (schemaJson.description ?? otherSchemaJson.description),
+    };
+};
+exports.mergeSchemas = mergeSchemas;

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

@@ -0,0 +1,9 @@
+import type { JSONSchema } from 'zod/v4/core';
+export type JsonSchema = JSONSchema.BaseSchema;
+export declare class JsonSchemaError extends Error {
+    constructor(message: string);
+}
+export declare const isAnyOf: (schema: JsonSchema) => schema is JSONSchema.BaseSchema & {
+    anyOf: JSONSchema.BaseSchema[];
+};
+//# sourceMappingURL=schema.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.types.d.ts","sourceRoot":"","sources":["../../../src/types/schema.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAA;AAE9C,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAED,eAAO,MAAM,OAAO,GAAI,QAAQ,UAAU,KAAG,MAAM,IAAI,UAAU,CAAC,UAAU,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC,UAAU,EAAE,CAAA;CAE9G,CAAA"}