@motiadev/core 0.14.0-beta.164 → 0.14.0-beta.165-707935

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

@@ -0,0 +1,97 @@
+import { StreamAdapter } from "../adapters/interfaces/stream-adapter.interface.mjs";
+import { v4 } from "uuid";
+
+//#region src/streams/redis-logs-stream.ts
+const LOG_TTL_SECONDS = 4320 * 60;
+var RedisLogsStream = class extends 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()}-${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 item = {
+			...data,
+			id: logId,
+			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 logs = (await this.client.mGet(keys)).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);
+	}
+};
+
+//#endregion
+export { RedisLogsStream };
+//# sourceMappingURL=redis-logs-stream.mjs.map

package/dist/src/streams/redis-logs-stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-logs-stream.mjs","names":["uuidv4","keys: string[]","cursor: string | number","item: BaseStreamItem<Log>"],"sources":["../../../src/streams/redis-logs-stream.ts"],"sourcesContent":["import type { RedisClientType } from 'redis'\nimport { v4 as uuidv4 } from 'uuid'\nimport { StreamAdapter } from '../adapters/interfaces/stream-adapter.interface'\nimport type { BaseStreamItem, StateStreamEvent } from '../types-stream'\n\nexport type Log = {\n  id: string\n  level: string\n  time: number\n  msg: string\n  traceId: string\n  flows: string[]\n  [key: string]: any\n}\n\nconst LOG_TTL_SECONDS = 3 * 24 * 60 * 60\n\nexport class RedisLogsStream extends StreamAdapter<Log> {\n  private client: RedisClientType\n  readonly keyPrefix = 'motia:logs:'\n\n  constructor(client: RedisClientType) {\n    super('__motia.logs')\n    this.client = client\n  }\n\n  private makeLogKey(groupId: string, id: string): string {\n    return `${this.keyPrefix}${groupId}:${id}`\n  }\n\n  private makeChannelKey(channel: { groupId: string; id: string }): string {\n    return `${this.keyPrefix}events:${channel.groupId}:${channel.id}`\n  }\n\n  private makeLogId(): string {\n    return `${Date.now()}-${uuidv4()}`\n  }\n\n  private async scanKeys(pattern: string): Promise<string[]> {\n    const keys: string[] = []\n    let cursor: string | number = '0'\n\n    do {\n      const result = await this.client.scan(cursor.toString(), {\n        MATCH: pattern,\n        COUNT: 100,\n      })\n      cursor = result.cursor\n      keys.push(...result.keys)\n    } while (String(cursor) !== '0')\n\n    return keys\n  }\n\n  async get(groupId: string, id: string): Promise<BaseStreamItem<Log> | null> {\n    const key = this.makeLogKey(groupId, id)\n    const value = await this.client.get(key)\n    return value ? JSON.parse(value) : null\n  }\n\n  async set(groupId: string, id: string, data: Log): Promise<BaseStreamItem<Log>> {\n    const logId = id || this.makeLogId()\n    const key = this.makeLogKey(groupId, logId)\n    const logData: Log = { ...data, id: logId }\n    const item: BaseStreamItem<Log> = { ...logData, id: logId }\n    const itemJson = JSON.stringify(item)\n\n    await Promise.all([\n      this.client.set(key, itemJson),\n      this.client.expire(key, LOG_TTL_SECONDS),\n      this.send({ groupId, id: logId }, { type: 'log', data: item }),\n    ])\n\n    return item\n  }\n\n  async delete(groupId: string, id: string): Promise<BaseStreamItem<Log> | null> {\n    const key = this.makeLogKey(groupId, id)\n    const value = await this.client.get(key)\n\n    if (!value) return null\n\n    const item = JSON.parse(value) as BaseStreamItem<Log>\n\n    await Promise.all([this.client.del(key), this.send({ groupId, id }, { type: 'delete', data: item })])\n\n    return item\n  }\n\n  async getGroup(groupId: string): Promise<BaseStreamItem<Log>[]> {\n    const pattern = `${this.keyPrefix}${groupId}:*`\n    const keys = await this.scanKeys(pattern)\n\n    if (keys.length === 0) return []\n\n    const values = await this.client.mGet(keys)\n    const logs = values.filter((v): v is string => v !== null).map((v) => JSON.parse(v) as BaseStreamItem<Log>)\n\n    const sortDesc = (a: BaseStreamItem<Log>, b: BaseStreamItem<Log>) => a.time - b.time\n    return logs.sort(sortDesc)\n  }\n\n  async send<T>(channel: { groupId: string; id: string }, event: StateStreamEvent<T>): Promise<void> {\n    const channelKey = this.makeChannelKey(channel)\n    await this.client.publish(channelKey, JSON.stringify(event))\n  }\n\n  async clear(groupId: string): Promise<void> {\n    const pattern = `${this.keyPrefix}${groupId}:*`\n    const keys = await this.scanKeys(pattern)\n\n    if (keys.length === 0) return\n\n    await this.client.del(keys)\n  }\n}\n"],"mappings":";;;;AAeA,MAAM,kBAAkB,OAAc;AAEtC,IAAa,kBAAb,cAAqC,cAAmB;CAItD,YAAY,QAAyB;AACnC,QAAM,eAAe;mBAHF;AAInB,OAAK,SAAS;;CAGhB,AAAQ,WAAW,SAAiB,IAAoB;AACtD,SAAO,GAAG,KAAK,YAAY,QAAQ,GAAG;;CAGxC,AAAQ,eAAe,SAAkD;AACvE,SAAO,GAAG,KAAK,UAAU,SAAS,QAAQ,QAAQ,GAAG,QAAQ;;CAG/D,AAAQ,YAAoB;AAC1B,SAAO,GAAG,KAAK,KAAK,CAAC,GAAGA,IAAQ;;CAGlC,MAAc,SAAS,SAAoC;EACzD,MAAMC,OAAiB,EAAE;EACzB,IAAIC,SAA0B;AAE9B,KAAG;GACD,MAAM,SAAS,MAAM,KAAK,OAAO,KAAK,OAAO,UAAU,EAAE;IACvD,OAAO;IACP,OAAO;IACR,CAAC;AACF,YAAS,OAAO;AAChB,QAAK,KAAK,GAAG,OAAO,KAAK;WAClB,OAAO,OAAO,KAAK;AAE5B,SAAO;;CAGT,MAAM,IAAI,SAAiB,IAAiD;EAC1E,MAAM,MAAM,KAAK,WAAW,SAAS,GAAG;EACxC,MAAM,QAAQ,MAAM,KAAK,OAAO,IAAI,IAAI;AACxC,SAAO,QAAQ,KAAK,MAAM,MAAM,GAAG;;CAGrC,MAAM,IAAI,SAAiB,IAAY,MAAyC;EAC9E,MAAM,QAAQ,MAAM,KAAK,WAAW;EACpC,MAAM,MAAM,KAAK,WAAW,SAAS,MAAM;EAE3C,MAAMC,OAA4B;GADX,GAAG;GAAM,IAAI;GACY,IAAI;GAAO;EAC3D,MAAM,WAAW,KAAK,UAAU,KAAK;AAErC,QAAM,QAAQ,IAAI;GAChB,KAAK,OAAO,IAAI,KAAK,SAAS;GAC9B,KAAK,OAAO,OAAO,KAAK,gBAAgB;GACxC,KAAK,KAAK;IAAE;IAAS,IAAI;IAAO,EAAE;IAAE,MAAM;IAAO,MAAM;IAAM,CAAC;GAC/D,CAAC;AAEF,SAAO;;CAGT,MAAM,OAAO,SAAiB,IAAiD;EAC7E,MAAM,MAAM,KAAK,WAAW,SAAS,GAAG;EACxC,MAAM,QAAQ,MAAM,KAAK,OAAO,IAAI,IAAI;AAExC,MAAI,CAAC,MAAO,QAAO;EAEnB,MAAM,OAAO,KAAK,MAAM,MAAM;AAE9B,QAAM,QAAQ,IAAI,CAAC,KAAK,OAAO,IAAI,IAAI,EAAE,KAAK,KAAK;GAAE;GAAS;GAAI,EAAE;GAAE,MAAM;GAAU,MAAM;GAAM,CAAC,CAAC,CAAC;AAErG,SAAO;;CAGT,MAAM,SAAS,SAAiD;EAC9D,MAAM,UAAU,GAAG,KAAK,YAAY,QAAQ;EAC5C,MAAM,OAAO,MAAM,KAAK,SAAS,QAAQ;AAEzC,MAAI,KAAK,WAAW,EAAG,QAAO,EAAE;EAGhC,MAAM,QADS,MAAM,KAAK,OAAO,KAAK,KAAK,EACvB,QAAQ,MAAmB,MAAM,KAAK,CAAC,KAAK,MAAM,KAAK,MAAM,EAAE,CAAwB;EAE3G,MAAM,YAAY,GAAwB,MAA2B,EAAE,OAAO,EAAE;AAChF,SAAO,KAAK,KAAK,SAAS;;CAG5B,MAAM,KAAQ,SAA0C,OAA2C;EACjG,MAAM,aAAa,KAAK,eAAe,QAAQ;AAC/C,QAAM,KAAK,OAAO,QAAQ,YAAY,KAAK,UAAU,MAAM,CAAC;;CAG9D,MAAM,MAAM,SAAgC;EAC1C,MAAM,UAAU,GAAG,KAAK,YAAY,QAAQ;EAC5C,MAAM,OAAO,MAAM,KAAK,SAAS,QAAQ;AAEzC,MAAI,KAAK,WAAW,EAAG;AAEvB,QAAM,KAAK,OAAO,IAAI,KAAK"}

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

@@ -0,0 +1,7 @@
+import { MotiaStream } from "../types-stream.mjs";
+
+//#region src/streams/stream-factory.d.ts
+type StreamFactory<TData> = () => MotiaStream<TData>;
+//#endregion
+export { StreamFactory };
+//# sourceMappingURL=stream-factory.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream-factory.d.mts","names":[],"sources":["../../../src/streams/stream-factory.ts"],"sourcesContent":[],"mappings":";;;KAEY,6BAA6B,YAAY"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"app-config-types.d.mts","names":[],"sources":["../../../src/types/app-config-types.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KASY,eAAA;;EAAA,aAAA,CAAA,EAAA,MAAe;EAWf,KAAA,CAAA,EAAA,MAAW;EAOX,SAAA,CAAA,EAAA,MAAA;EAEA,QAAA,CAAA,EAAA,QAAa,GAAA,KAAA;EACf,UAAA,CAAA,EAAA,MAAA,EAAA;EACE,KAAA,CAAA,EAdF,MAcE,CAAA,MAAA,EAAA,GAAA,CAAA;CACD;AACF,KAbG,WAAA,GAaH;EAAW,SAAA,EAZP,eAYO,EAAA;EAGR,OAAA,CAAA,EAAA,MAAA;EAKA,KAAA,CAAA,EAAA,MAAA,EAAA;EAAmC,UAAA,CAAA,EAAA,GAAA,GAjB1B,OAiB0B,CAAA,IAAA,CAAA;CAAa;AAC3C,KAfL,kBAAA,GAeK,CAAA,KAAA,EAfwB,kBAexB,EAAA,GAf+C,WAe/C;AACS,KAdd,aAAA,GAcc;EAAsC,KAAA,CAAA,EAbtD,YAasD;EAAN,OAAA,CAAA,EAZ9C,oBAY8C;EAAV,MAAA,CAAA,EAXrC,YAWqC;EAA4C,IAAA,CAAA,EAVnF,WAUmF;CAAR;AAAO,KAP/E,iBAAA,GAO+E;EAG/E,OAAA,EATD,MASO,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA,CAAA;EACJ,GAAA,CAAA,EAAA,MAAA;CACF;AACC,KARD,gBAQC,CAAA,gBARgC,CAAA,CAAE,UAQlC,GAR+C,CAAA,CAAE,UAQjD,CAAA,GAAA;EACE,aAAA,EARE,UAQF;EAAgB,YAAA,EAAA,CAAA,OAAA,EAPL,iBAOK,EAAA,GAPiB,OAOjB,CAPyB,CAAA,CAAE,KAO3B,CAPiC,OAOjC,CAAA,GAAA,IAAA,CAAA,GAAA,CAPqD,CAAA,CAAE,KAOvD,CAP6D,OAO7D,CAAA,GAAA,IAAA,CAAA;;KAJnB,MAAA;cACE;YACF;aACC;eACE"}

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

@@ -0,0 +1,30 @@
+import { isAnyOf } from "./schema.types.mjs";
+
+//#region src/types/generate-type-from-schema.ts
+const generateTypeFromSchema = (schema) => {
+	if (!schema) return "unknown";
+	if (isAnyOf(schema)) return schema.anyOf.map(generateTypeFromSchema).join(" | ");
+	if (schema.type === "array") return `Array<${schema.items ? generateTypeFromSchema(schema.items) : "unknown"}>`;
+	if (schema.type === "object" && schema.properties) {
+		const props = Object.entries(schema.properties).map(([key, prop]) => {
+			const isRequired = schema.required?.includes(key);
+			const propType = generateTypeFromSchema(prop);
+			return `${key}${isRequired ? "" : "?"}: ${propType}`;
+		});
+		return props.length > 0 ? `{ ${props.join("; ")} }` : "{}";
+	} else if (schema.type === "object" && schema.additionalProperties) return `Record<string, ${generateTypeFromSchema(schema.additionalProperties)}>`;
+	if (schema.type === "string") {
+		if (schema.format === "binary") return "Buffer";
+		return schema.enum && schema.enum.length > 0 ? 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";
+	}
+};
+
+//#endregion
+export { generateTypeFromSchema };
+//# sourceMappingURL=generate-type-from-schema.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-type-from-schema.mjs","names":[],"sources":["../../../src/types/generate-type-from-schema.ts"],"sourcesContent":["import type { JSONSchema } from 'zod/v4/core'\nimport { isAnyOf } from './schema.types'\n\nexport const generateTypeFromSchema = (schema: JSONSchema.BaseSchema): string => {\n  if (!schema) {\n    return 'unknown'\n  }\n\n  if (isAnyOf(schema)) {\n    const types = schema.anyOf.map(generateTypeFromSchema)\n    return types.join(' | ')\n  }\n\n  if (schema.type === 'array') {\n    const itemType = schema.items ? generateTypeFromSchema(schema.items as JSONSchema.ArraySchema) : 'unknown'\n    return `Array<${itemType}>`\n  }\n\n  if (schema.type === 'object' && schema.properties) {\n    const props = Object.entries(schema.properties).map(([key, prop]) => {\n      const isRequired = schema.required?.includes(key)\n      const propType = generateTypeFromSchema(prop as JSONSchema.BaseSchema)\n      return `${key}${isRequired ? '' : '?'}: ${propType}`\n    })\n    return props.length > 0 ? `{ ${props.join('; ')} }` : '{}'\n  } else if (schema.type === 'object' && schema.additionalProperties) {\n    const propType = generateTypeFromSchema(schema.additionalProperties as JSONSchema.BaseSchema)\n    return `Record<string, ${propType}>`\n  }\n\n  if (schema.type === 'string') {\n    if (schema.format === 'binary') {\n      return 'Buffer'\n    }\n    return schema.enum && schema.enum.length > 0 // must have at least one enum value\n      ? schema.enum.map((value) => `'${value}'`).join(' | ')\n      : 'string'\n  }\n\n  if (typeof schema === 'object' && schema !== null && 'not' in schema) {\n    return 'undefined'\n  }\n\n  switch (schema.type) {\n    case 'number':\n      return 'number'\n    case 'boolean':\n      return 'boolean'\n    default:\n      return 'unknown'\n  }\n}\n"],"mappings":";;;AAGA,MAAa,0BAA0B,WAA0C;AAC/E,KAAI,CAAC,OACH,QAAO;AAGT,KAAI,QAAQ,OAAO,CAEjB,QADc,OAAO,MAAM,IAAI,uBAAuB,CACzC,KAAK,MAAM;AAG1B,KAAI,OAAO,SAAS,QAElB,QAAO,SADU,OAAO,QAAQ,uBAAuB,OAAO,MAAgC,GAAG,UACxE;AAG3B,KAAI,OAAO,SAAS,YAAY,OAAO,YAAY;EACjD,MAAM,QAAQ,OAAO,QAAQ,OAAO,WAAW,CAAC,KAAK,CAAC,KAAK,UAAU;GACnE,MAAM,aAAa,OAAO,UAAU,SAAS,IAAI;GACjD,MAAM,WAAW,uBAAuB,KAA8B;AACtE,UAAO,GAAG,MAAM,aAAa,KAAK,IAAI,IAAI;IAC1C;AACF,SAAO,MAAM,SAAS,IAAI,KAAK,MAAM,KAAK,KAAK,CAAC,MAAM;YAC7C,OAAO,SAAS,YAAY,OAAO,qBAE5C,QAAO,kBADU,uBAAuB,OAAO,qBAA8C,CAC3D;AAGpC,KAAI,OAAO,SAAS,UAAU;AAC5B,MAAI,OAAO,WAAW,SACpB,QAAO;AAET,SAAO,OAAO,QAAQ,OAAO,KAAK,SAAS,IACvC,OAAO,KAAK,KAAK,UAAU,IAAI,MAAM,GAAG,CAAC,KAAK,MAAM,GACpD;;AAGN,KAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,SAAS,OAC5D,QAAO;AAGT,SAAQ,OAAO,MAAf;EACE,KAAK,SACH,QAAO;EACT,KAAK,UACH,QAAO;EACT,QACE,QAAO"}

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

@@ -0,0 +1,12 @@
+import { generateTypeFromSchema } from "./generate-type-from-schema.mjs";
+
+//#region src/types/generate-types-from-response.ts
+const generateTypesFromResponse = (record) => {
+	return Object.entries(record).map(([status, schema]) => {
+		return `ApiResponse<${status}, ${generateTypeFromSchema(schema)}>`;
+	}).join(" | ");
+};
+
+//#endregion
+export { generateTypesFromResponse };
+//# sourceMappingURL=generate-types-from-response.mjs.map

package/dist/src/types/generate-types-from-response.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types-from-response.mjs","names":[],"sources":["../../../src/types/generate-types-from-response.ts"],"sourcesContent":["import { generateTypeFromSchema } from './generate-type-from-schema'\nimport type { JsonSchema } from './schema.types'\n\nexport const generateTypesFromResponse = (record: Record<number, JsonSchema>): string => {\n  return Object.entries(record)\n    .map(([status, schema]) => {\n      const schemaType = generateTypeFromSchema(schema as JsonSchema)\n      return `ApiResponse<${status}, ${schemaType}>`\n    })\n    .join(' | ')\n}\n"],"mappings":";;;AAGA,MAAa,6BAA6B,WAA+C;AACvF,QAAO,OAAO,QAAQ,OAAO,CAC1B,KAAK,CAAC,QAAQ,YAAY;AAEzB,SAAO,eAAe,OAAO,IADV,uBAAuB,OAAqB,CACnB;GAC5C,CACD,KAAK,MAAM"}

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

@@ -0,0 +1,101 @@
+import { isApiStep, isCronStep, isEventStep } from "../guards.mjs";
+import { generateTypeFromSchema } from "./generate-type-from-schema.mjs";
+import { schemaToJsonSchema } from "../schema-utils.mjs";
+import { generateTypesFromResponse } from "./generate-types-from-response.mjs";
+import { mergeSchemas } from "./merge-schemas.mjs";
+
+//#region src/types/generate-types.ts
+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}` : ""}
+}`;
+};
+const generateTypesFromSteps = (steps, printer) => {
+	const handlers = {};
+	const topics = {};
+	const topicsSchemas = {};
+	const topicsSteps = {};
+	const topicIsFifo = {};
+	for (const step of steps) if (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);
+			if (step.config.infrastructure?.queue?.type === "fifo") topicIsFifo[topic] = true;
+			try {
+				const input = step.config.input;
+				const schema = existingSchema ? mergeSchemas(existingSchema, input) : schemaToJsonSchema(input) ?? input;
+				topics[topic] = 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$1) => {
+			const topic = typeof emit$1 === "string" ? emit$1 : emit$1.topic;
+			const topicType = topics[topic];
+			if (topicType) if (topicIsFifo[topic]) 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 (isEventStep(step)) {
+			const input = step.config.input ? generateTypeFromSchema(step.config.input) : "never";
+			handlers[step.config.name] = {
+				type: "EventHandler",
+				generics: [input, emits]
+			};
+		} else if (isApiStep(step)) {
+			const input = step.config.bodySchema ? generateTypeFromSchema(step.config.bodySchema) : "Record<string, unknown>";
+			const result = step.config.responseSchema ? generateTypesFromResponse(step.config.responseSchema) : "unknown";
+			handlers[step.config.name] = {
+				type: "ApiRouteHandler",
+				generics: [
+					input,
+					result,
+					emits
+				]
+			};
+		} else if (isCronStep(step)) handlers[step.config.name] = {
+			type: "CronHandler",
+			generics: [emits]
+		};
+	}
+	return handlers;
+};
+const generateTypesFromStreams = (streams) => {
+	return Object.entries(streams).reduce((acc, [key, stream]) => {
+		if (!stream.hidden) acc[key] = generateTypeFromSchema(stream.config.schema);
+		return acc;
+	}, {});
+};
+
+//#endregion
+export { generateTypesFromSteps, generateTypesFromStreams, generateTypesString };
+//# sourceMappingURL=generate-types.mjs.map

package/dist/src/types/generate-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types.mjs","names":["handlers: HandlersMap","topics: Record<string, string>","topicsSchemas: Record<string, JsonSchema>","topicsSteps: Record<string, Step[]>","topicIsFifo: Record<string, boolean>","emit"],"sources":["../../../src/types/generate-types.ts"],"sourcesContent":["import { isApiStep, isCronStep, isEventStep } from '../guards'\nimport type { Printer } from '../printer'\nimport { schemaToJsonSchema } from '../schema-utils'\nimport type { Emit, Step } from '../types'\nimport type { Stream } from '../types-stream'\nimport { generateTypeFromSchema } from './generate-type-from-schema'\nimport { generateTypesFromResponse } from './generate-types-from-response'\nimport { mergeSchemas } from './merge-schemas'\nimport type { JsonSchema } from './schema.types'\n\ntype HandlersMap = Record<string, { type: string; generics: string[] }>\ntype StreamsMap = Record<string, string>\n\nexport const generateTypesString = (\n  handlers: HandlersMap,\n  streams: StreamsMap,\n  streamAuthContextType?: string,\n): string => {\n  return `/**\n * Automatically generated types for motia\n * Do NOT edit this file manually.\n * \n * Consider adding this file to .prettierignore and eslint ignore.\n */\nimport { EventHandler, ApiRouteHandler, ApiResponse, MotiaStream, CronHandler } from 'motia'\n\ndeclare module 'motia' {\n  interface FlowContextStateStreams {\n    ${Object.entries(streams)\n      .map(([key, value]) => `'${key}': MotiaStream<${value}>`)\n      .join('\\n    ')\n      .trim()}\n  }\n\n  interface Handlers {\n    ${Object.entries(handlers)\n      .map(([key, { type, generics }]) => `'${key}': ${type}<${generics.join(', ')}>`)\n      .join('\\n    ')\n      .trim()}\n  }\n    ${streamAuthContextType ? `interface StreamAuthContext ${streamAuthContextType}` : ''}\n}`\n}\n\nexport const generateTypesFromSteps = (steps: Step[], printer: Printer): HandlersMap => {\n  const handlers: HandlersMap = {}\n  const topics: Record<string, string> = {}\n  const topicsSchemas: Record<string, JsonSchema> = {}\n  const topicsSteps: Record<string, Step[]> = {}\n  const topicIsFifo: Record<string, boolean> = {}\n\n  for (const step of steps) {\n    if (isEventStep(step)) {\n      if (!step.config.input) {\n        for (const topic of step.config.subscribes) {\n          if (!topics[topic]) {\n            topics[topic] = 'never'\n          }\n        }\n        continue\n      }\n\n      for (const topic of step.config.subscribes) {\n        const existingSchema = topicsSchemas[topic]\n\n        topicsSteps[topic] = topicsSteps[topic] ?? []\n        topicsSteps[topic].push(step)\n\n        const queueType = step.config.infrastructure?.queue?.type\n        if (queueType === 'fifo') {\n          topicIsFifo[topic] = true\n        }\n\n        try {\n          const input = step.config.input\n          const schema = existingSchema\n            ? mergeSchemas(existingSchema, input)\n            : (schemaToJsonSchema(input) ?? (input as JsonSchema))\n          topics[topic] = generateTypeFromSchema(schema)\n          topicsSchemas[topic] = schema\n        } catch (error) {\n          printer.printInvalidSchema(topic, topicsSteps[topic])\n          topics[topic] = 'never'\n        }\n      }\n    }\n  }\n\n  const generateEmitData = (emit: Emit[], step: Step): string => {\n    const emits = emit\n      .reduce((acc, emit) => {\n        const topic = typeof emit === 'string' ? emit : emit.topic\n        const topicType = topics[topic]\n\n        if (topicType) {\n          const isFifo = topicIsFifo[topic]\n          if (isFifo) {\n            acc.push(`{ topic: '${topic.replace(/'/g, \"\\\\'\")}'; data: ${topicType}; messageGroupId: string }`)\n          } else {\n            acc.push(`{ topic: '${topic.replace(/'/g, \"\\\\'\")}'; data: ${topicType} }`)\n          }\n        } else {\n          printer.printInvalidEmitConfiguration(step, topic)\n        }\n\n        return acc\n      }, [] as string[])\n      .join(' | ')\n\n    return emits.length === 0 ? 'never' : emits\n  }\n\n  for (const step of steps) {\n    const emits = 'emits' in step.config ? generateEmitData(step.config.emits, step) : 'never'\n\n    if (isEventStep(step)) {\n      const input = step.config.input ? generateTypeFromSchema(step.config.input as never as JsonSchema) : 'never'\n      handlers[step.config.name] = { type: 'EventHandler', generics: [input, emits] }\n    } else if (isApiStep(step)) {\n      const input = step.config.bodySchema\n        ? generateTypeFromSchema(step.config.bodySchema as never as JsonSchema)\n        : 'Record<string, unknown>'\n      const result = step.config.responseSchema\n        ? generateTypesFromResponse(step.config.responseSchema as never as Record<number, JsonSchema>)\n        : 'unknown'\n      handlers[step.config.name] = { type: 'ApiRouteHandler', generics: [input, result, emits] }\n    } else if (isCronStep(step)) {\n      handlers[step.config.name] = { type: 'CronHandler', generics: [emits] }\n    }\n  }\n\n  return handlers\n}\n\nexport const generateTypesFromStreams = (streams: Record<string, Stream>): StreamsMap => {\n  return Object.entries(streams).reduce((acc, [key, stream]) => {\n    if (!stream.hidden) {\n      acc[key] = generateTypeFromSchema(stream.config.schema as unknown as JsonSchema)\n    }\n    return acc\n  }, {} as StreamsMap)\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,102 @@
+import { JsonSchemaError, isAnyOf } from "./schema.types.mjs";
+import { isZodSchema, schemaToJsonSchema } from "../schema-utils.mjs";
+import * as z$1 from "zod";
+
+//#region src/types/merge-schemas.ts
+const isJsonSchema = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value !== "boolean";
+};
+const isCompatible = (schema, otherSchema) => {
+	if (isAnyOf(schema)) return schema.anyOf.every((item) => isCompatible(item, otherSchema));
+	else if (isAnyOf(otherSchema)) return otherSchema.anyOf.every((item) => 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 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 isCompatible(prop1, prop2);
+			return prop1 === prop2;
+		});
+	}
+	return true;
+};
+const mergeZodSchemas = (schema, otherSchema) => {
+	try {
+		return z$1.intersection(schema, otherSchema);
+	} catch (error) {
+		throw new JsonSchemaError(`Cannot merge Zod schemas: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+};
+const mergeSchemas = (schema, otherSchema) => {
+	if (isZodSchema(schema) && isZodSchema(otherSchema)) {
+		const jsonSchema = schemaToJsonSchema(mergeZodSchemas(schema, otherSchema));
+		if (!jsonSchema) throw new JsonSchemaError("Failed to convert merged Zod schema to JSON Schema");
+		return jsonSchema;
+	}
+	const schemaJsonResult = schemaToJsonSchema(schema);
+	const otherSchemaJsonResult = schemaToJsonSchema(otherSchema);
+	if (!schemaJsonResult || !otherSchemaJsonResult) throw new JsonSchemaError("Cannot merge schemas: failed to convert to JSON Schema");
+	const schemaJson = schemaJsonResult;
+	const otherSchemaJson = otherSchemaJsonResult;
+	if (!isCompatible(schemaJson, otherSchemaJson)) throw new JsonSchemaError("Cannot merge schemas of different types");
+	if (isAnyOf(schemaJson)) return { anyOf: schemaJson.anyOf.map((item) => mergeSchemas(item, otherSchemaJson)) };
+	else if (isAnyOf(otherSchemaJson)) return { anyOf: otherSchemaJson.anyOf.map((item) => mergeSchemas(schemaJson, item)) };
+	if (schemaJson.type === "object" && otherSchemaJson.type === "object") {
+		const schemaProps = schemaJson.properties;
+		const otherSchemaProps = otherSchemaJson.properties;
+		if (!schemaProps || !otherSchemaProps) throw new 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] = 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 JsonSchemaError("Cannot merge array schemas without items");
+		if (Array.isArray(schemaJson.items) || Array.isArray(otherSchemaJson.items)) throw new JsonSchemaError("Cannot merge array schemas with array items");
+		if (!isJsonSchema(schemaJson.items) || !isJsonSchema(otherSchemaJson.items)) throw new JsonSchemaError("Cannot merge array schemas with non-object items");
+		return {
+			type: "array",
+			items: mergeSchemas(schemaJson.items, otherSchemaJson.items)
+		};
+	}
+	return {
+		type: schemaJson.type,
+		description: schemaJson.description ?? otherSchemaJson.description
+	};
+};
+
+//#endregion
+export { mergeSchemas };
+//# sourceMappingURL=merge-schemas.mjs.map

package/dist/src/types/merge-schemas.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-schemas.mjs","names":["z","mergedProperties: Record<string, JSONSchema._JSONSchema>"],"sources":["../../../src/types/merge-schemas.ts"],"sourcesContent":["import * as z from 'zod'\nimport type { JSONSchema } from 'zod/v4/core'\nimport { isZodSchema, type SchemaInput, schemaToJsonSchema } from '../schema-utils'\nimport { isAnyOf, type JsonSchema, JsonSchemaError } from './schema.types'\n\nconst isJsonSchema = (value: unknown): value is JsonSchema => {\n  return typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value !== 'boolean'\n}\n\nexport const isCompatible = (schema: JsonSchema, otherSchema: JsonSchema): boolean => {\n  if (isAnyOf(schema)) {\n    return schema.anyOf.every((item) => isCompatible(item, otherSchema))\n  } else if (isAnyOf(otherSchema)) {\n    return otherSchema.anyOf.every((item) => isCompatible(schema, item))\n  }\n\n  if (schema.type !== otherSchema.type) {\n    return false\n  }\n\n  if (schema.type === 'array' && otherSchema.type === 'array') {\n    if (!schema.items || !otherSchema.items) {\n      return schema.items === otherSchema.items\n    }\n    if (Array.isArray(schema.items) || Array.isArray(otherSchema.items)) {\n      return false\n    }\n    if (isJsonSchema(schema.items) && isJsonSchema(otherSchema.items)) {\n      return isCompatible(schema.items, otherSchema.items)\n    }\n    return schema.items === otherSchema.items\n  }\n\n  if (schema.type === 'object' && otherSchema.type === 'object') {\n    const schemaProps = schema.properties\n    const otherSchemaProps = otherSchema.properties\n    if (!schemaProps || !otherSchemaProps) {\n      return schemaProps === otherSchemaProps\n    }\n    const keysFromSchema = Object.keys(schemaProps)\n    const keysFromOtherSchema = Object.keys(otherSchemaProps)\n    const commonKeys = keysFromSchema.filter((key) => keysFromOtherSchema.includes(key))\n\n    if (schema.required?.some((key) => !keysFromOtherSchema.includes(key))) {\n      return false\n    } else if (otherSchema.required?.some((key) => !keysFromSchema.includes(key))) {\n      return false\n    }\n\n    if (commonKeys.length > 0) {\n      return commonKeys.every((key) => {\n        const prop1 = schemaProps[key]\n        const prop2 = otherSchemaProps[key]\n        if (isJsonSchema(prop1) && isJsonSchema(prop2)) {\n          return isCompatible(prop1, prop2)\n        }\n        return prop1 === prop2\n      })\n    }\n  }\n\n  return true\n}\n\nconst mergeZodSchemas = (schema: z.ZodType, otherSchema: z.ZodType): z.ZodType => {\n  try {\n    return z.intersection(schema, otherSchema)\n  } catch (error) {\n    throw new JsonSchemaError(`Cannot merge Zod schemas: ${error instanceof Error ? error.message : 'Unknown error'}`)\n  }\n}\n\nexport const mergeSchemas = (schema: SchemaInput, otherSchema: SchemaInput): JsonSchema => {\n  if (isZodSchema(schema) && isZodSchema(otherSchema)) {\n    const mergedZodSchema = mergeZodSchemas(schema, otherSchema)\n    const jsonSchema = schemaToJsonSchema(mergedZodSchema)\n    if (!jsonSchema) {\n      throw new JsonSchemaError('Failed to convert merged Zod schema to JSON Schema')\n    }\n    return jsonSchema as JsonSchema\n  }\n\n  const schemaJsonResult = schemaToJsonSchema(schema)\n  const otherSchemaJsonResult = schemaToJsonSchema(otherSchema)\n\n  if (!schemaJsonResult || !otherSchemaJsonResult) {\n    throw new JsonSchemaError('Cannot merge schemas: failed to convert to JSON Schema')\n  }\n\n  const schemaJson = schemaJsonResult as JsonSchema\n  const otherSchemaJson = otherSchemaJsonResult as JsonSchema\n\n  if (!isCompatible(schemaJson, otherSchemaJson)) {\n    throw new JsonSchemaError('Cannot merge schemas of different types')\n  }\n\n  if (isAnyOf(schemaJson)) {\n    return {\n      anyOf: schemaJson.anyOf.map((item) => mergeSchemas(item, otherSchemaJson)),\n    }\n  } else if (isAnyOf(otherSchemaJson)) {\n    return {\n      anyOf: otherSchemaJson.anyOf.map((item) => mergeSchemas(schemaJson, item)),\n    }\n  }\n\n  if (schemaJson.type === 'object' && otherSchemaJson.type === 'object') {\n    const schemaProps = schemaJson.properties as Record<string, JSONSchema._JSONSchema> | undefined\n    const otherSchemaProps = otherSchemaJson.properties as Record<string, JSONSchema._JSONSchema> | undefined\n    if (!schemaProps || !otherSchemaProps) {\n      throw new JsonSchemaError('Cannot merge object schemas without properties')\n    }\n    const mergedProperties: Record<string, JSONSchema._JSONSchema> = { ...schemaProps, ...otherSchemaProps }\n    const otherSchemaKeys = Object.keys(otherSchemaProps).reduce(\n      (acc, key) => {\n        acc[key] = true\n        return acc\n      },\n      {} as Record<string, boolean>,\n    )\n\n    for (const key in schemaProps) {\n      if (otherSchemaKeys[key]) {\n        const prop1 = schemaProps[key]\n        const prop2 = otherSchemaProps[key]\n        if (isJsonSchema(prop1) && isJsonSchema(prop2)) {\n          mergedProperties[key] = mergeSchemas(prop1, prop2)\n        } else {\n          mergedProperties[key] = prop2\n        }\n      }\n    }\n\n    const schemaRequired = schemaJson.required as string[] | undefined\n    const otherSchemaRequired = otherSchemaJson.required as string[] | undefined\n    const mergedRequired = new Set([...(schemaRequired ?? []), ...(otherSchemaRequired ?? [])])\n\n    return {\n      type: 'object',\n      properties: mergedProperties,\n      required: Array.from(mergedRequired),\n    }\n  }\n\n  if (schemaJson.type === 'array' && otherSchemaJson.type === 'array') {\n    if (!schemaJson.items || !otherSchemaJson.items) {\n      throw new JsonSchemaError('Cannot merge array schemas without items')\n    }\n    if (Array.isArray(schemaJson.items) || Array.isArray(otherSchemaJson.items)) {\n      throw new JsonSchemaError('Cannot merge array schemas with array items')\n    }\n    if (!isJsonSchema(schemaJson.items) || !isJsonSchema(otherSchemaJson.items)) {\n      throw new JsonSchemaError('Cannot merge array schemas with non-object items')\n    }\n    return {\n      type: 'array',\n      items: mergeSchemas(schemaJson.items, otherSchemaJson.items),\n    }\n  }\n\n  return {\n    type: schemaJson.type as JSONSchema.BaseSchema['type'],\n    description: (schemaJson.description ?? otherSchemaJson.description) as string | undefined,\n  }\n}\n"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.types.d.mts","names":[],"sources":["../../../src/types/schema.types.ts"],"sourcesContent":[],"mappings":";;;KAEY,UAAA,GAAa,UAAA,CAAW;cAEvB,eAAA,SAAwB,KAAA;EAFzB,WAAA,CAAA,OAAU,EAAA,MAAG;AAEzB;AAOa,cAAA,OAEZ,EAAA,CAAA,MAAA,EAF+B,UAE/B,EAAA,GAAA,MAAA,IAFsD,UAAA,CAAW,UAEjE,GAAA;EAF+B,KAAA,EAAwD,UAAA,CAAW,UAAnE,EAAA;CAAuB"}

package/dist/src/types/schema.types.mjs

@@ -0,0 +1,14 @@
+//#region src/types/schema.types.ts
+var JsonSchemaError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "JsonSchemaError";
+	}
+};
+const isAnyOf = (schema) => {
+	return typeof schema === "object" && schema !== null && "anyOf" in schema;
+};
+
+//#endregion
+export { JsonSchemaError, isAnyOf };
+//# sourceMappingURL=schema.types.mjs.map

package/dist/src/types/schema.types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.types.mjs","names":[],"sources":["../../../src/types/schema.types.ts"],"sourcesContent":["import type { JSONSchema } from 'zod/v4/core'\n\nexport type JsonSchema = JSONSchema.BaseSchema\n\nexport class JsonSchemaError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'JsonSchemaError'\n  }\n}\n\nexport const isAnyOf = (schema: JsonSchema): schema is JSONSchema.BaseSchema & { anyOf: JSONSchema.BaseSchema[] } => {\n  return typeof schema === 'object' && schema !== null && 'anyOf' in schema\n}\n"],"mappings":";AAIA,IAAa,kBAAb,cAAqC,MAAM;CACzC,YAAY,SAAiB;AAC3B,QAAM,QAAQ;AACd,OAAK,OAAO;;;AAIhB,MAAa,WAAW,WAA6F;AACnH,QAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,WAAW"}

package/dist/src/types-stream.d.mts

@@ -0,0 +1,46 @@
+import { StreamFactory } from "./streams/stream-factory.mjs";
+import { StepSchemaInput } from "./types.mjs";
+
+//#region src/types-stream.d.ts
+type StreamSubscription = {
+  groupId: string;
+  id?: string;
+};
+interface StreamConfig {
+  name: string;
+  schema: StepSchemaInput;
+  baseConfig: {
+    storageType: 'default';
+  } | {
+    storageType: 'custom';
+    factory: () => MotiaStream<any>;
+  };
+  canAccess?: (subscription: StreamSubscription, authContext: any) => boolean | Promise<boolean>;
+}
+type StateStreamEventChannel = {
+  groupId: string;
+  id?: string;
+};
+type StateStreamEvent<TData> = {
+  type: string;
+  data: TData;
+};
+type BaseStreamItem<TData = unknown> = TData & {
+  id: string;
+};
+type Stream<TConfig extends StreamConfig = StreamConfig> = {
+  filePath: string;
+  config: TConfig;
+  hidden?: boolean;
+  factory: StreamFactory<unknown>;
+};
+interface MotiaStream<TData> {
+  get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+  set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData>>;
+  delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+  getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
+  send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>;
+}
+//#endregion
+export { BaseStreamItem, MotiaStream, StateStreamEvent, StateStreamEventChannel, Stream, StreamConfig, StreamSubscription };
+//# sourceMappingURL=types-stream.d.mts.map

package/dist/src/types-stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-stream.d.mts","names":[],"sources":["../../src/types-stream.ts"],"sourcesContent":[],"mappings":";;;;KAGY,kBAAA;;EAAA,EAAA,CAAA,EAAA,MAAA;AAEZ,CAAA;AAEU,UAFO,YAAA,CAEP;EACyE,IAAA,EAAA,MAAA;EACtD,MAAA,EAFnB,eAEmB;EAAmD,UAAA,EAAA;IAAO,WAAA,EAAA,SAAA;EAG3E,CAAA,GAAA;IACA,WAAA,EAAA,QAAgB;IAEhB,OAAA,EAAA,GAAA,GAPuE,WAOzD,CAAA,GAAoB,CAAA;EAElC,CAAA;EAAuB,SAAA,CAAA,EAAA,CAAA,YAAA,EARN,kBAQM,EAAA,WAAA,EAAA,GAAA,EAAA,GAAA,OAAA,GAR6C,OAQ7C,CAAA,OAAA,CAAA;;AAEzB,KAPE,uBAAA,GAOF;EAEC,OAAA,EAAA,MAAA;EAAa,EAAA,CAAA,EAAA,MAAA;AAGxB,CAAA;AAC2D,KAZ/C,gBAY+C,CAAA,KAAA,CAAA,GAAA;EAAf,IAAA,EAAA,MAAA;EAAR,IAAA,EAZwB,KAYxB;CACK;AAA+B,KAX5D,cAW4D,CAAA,QAAA,OAAA,CAAA,GAX1B,KAW0B,GAAA;EAAf,EAAA,EAAA,MAAA;CAAR;AACa,KAVlD,MAUkD,CAAA,gBAV3B,YAU2B,GAVZ,YAUY,CAAA,GAAA;EAAf,QAAA,EAAA,MAAA;EAAR,MAAA,EAR7B,OAQ6B;EACa,MAAA,CAAA,EAAA,OAAA;EAAf,OAAA,EAP1B,aAO0B,CAAA,OAAA,CAAA;CAAR;AAEV,UANF,WAME,CAAA,KAAA,CAAA,CAAA;EAAiD,GAAA,CAAA,OAAA,EAAA,MAAA,EAAA,EAAA,EAAA,MAAA,CAAA,EALhC,OAKgC,CALxB,cAKwB,CALT,KAKS,CAAA,GAAA,IAAA,CAAA;EAAjB,GAAA,CAAA,OAAA,EAAA,MAAA,EAAA,EAAA,EAAA,MAAA,EAAA,IAAA,EAJV,KAIU,CAAA,EAJF,OAIE,CAJM,cAIN,CAJqB,KAIrB,CAAA,CAAA;EAAsB,MAAA,CAAA,OAAA,EAAA,MAAA,EAAA,EAAA,EAAA,MAAA,CAAA,EAHlC,OAGkC,CAH1B,cAG0B,CAHX,KAGW,CAAA,GAAA,IAAA,CAAA;EAAO,QAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAFnD,OAEmD,CAF3C,cAE2C,CAF5B,KAE4B,CAAA,EAAA,CAAA;mBAA7D,gCAAgC,iBAAiB,KAAK"}