@motiadev/test 0.13.2-beta.163 → 0.13.2-beta.164-562802

package/dist/event-manager.d.mts

@@ -0,0 +1,12 @@
+import { Event, EventAdapter } from "@motiadev/core";
+
+//#region src/event-manager.d.ts
+interface TestEventManager {
+  emit: <TData>(event: Event<TData>, file?: string) => Promise<void>;
+  waitEvents(): Promise<void>;
+  subscribe: <TData>(topic: string, stepName: string, handler: (event: Event<TData>) => void | Promise<void>) => void;
+}
+declare const createEventManager: (eventAdapter: EventAdapter) => TestEventManager;
+//#endregion
+export { createEventManager };
+//# sourceMappingURL=event-manager.d.mts.map

package/dist/event-manager.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-manager.d.mts","names":[],"sources":["../src/event-manager.ts"],"sourcesContent":[],"mappings":";;;UAGU,gBAAA;uBACa,MAAM,0BAA0B;EAD7C,UAAA,EAAA,EAEM,OAFU,CAAA,IAAA,CAAA;EACG,SAAA,EAAA,CAAA,KAAA,CAAA,CAAA,KAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,EAAA,OAAA,EAAA,CAAA,KAAA,EAE0C,KAF1C,CAEgD,KAFhD,CAAA,EAAA,GAAA,IAAA,GAEkE,OAFlE,CAAA,IAAA,CAAA,EAAA,GAAA,IAAA;;AAA0B,cAK1C,kBAL0C,EAAA,CAAA,YAAA,EAKN,YALM,EAAA,GAKS,gBALT"}

package/dist/event-manager.mjs

@@ -0,0 +1,29 @@
+import { DefaultQueueEventAdapter } from "@motiadev/core";
+
+//#region src/event-manager.ts
+const createEventManager = (eventAdapter) => {
+	const waitEvents = async () => {
+		await new Promise((resolve) => setTimeout(resolve, 200));
+		if (eventAdapter instanceof DefaultQueueEventAdapter) {
+			let hasWork = true;
+			while (hasWork) {
+				await new Promise((resolve) => setTimeout(resolve, 100));
+				const metrics = eventAdapter.getAllMetrics();
+				hasWork = Object.values(metrics).some((m) => m.queueDepth > 0 || m.processingCount > 0);
+			}
+		}
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	};
+	const subscribe = (topic, stepName, handler) => {
+		eventAdapter.subscribe(topic, stepName, handler);
+	};
+	return {
+		emit: eventAdapter.emit,
+		waitEvents,
+		subscribe
+	};
+};
+
+//#endregion
+export { createEventManager };
+//# sourceMappingURL=event-manager.mjs.map

package/dist/event-manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-manager.mjs","names":["metrics: Record<string, QueueMetrics>"],"sources":["../src/event-manager.ts"],"sourcesContent":["import type { Event, EventAdapter, QueueMetrics } from '@motiadev/core'\nimport { DefaultQueueEventAdapter } from '@motiadev/core'\n\ninterface TestEventManager {\n  emit: <TData>(event: Event<TData>, file?: string) => Promise<void>\n  waitEvents(): Promise<void>\n  subscribe: <TData>(topic: string, stepName: string, handler: (event: Event<TData>) => void | Promise<void>) => void\n}\n\nexport const createEventManager = (eventAdapter: EventAdapter): TestEventManager => {\n  const waitEvents = async () => {\n    await new Promise((resolve) => setTimeout(resolve, 200))\n\n    if (eventAdapter instanceof DefaultQueueEventAdapter) {\n      let hasWork = true\n      while (hasWork) {\n        await new Promise((resolve) => setTimeout(resolve, 100))\n        const metrics: Record<string, QueueMetrics> = eventAdapter.getAllMetrics()\n        hasWork = Object.values(metrics).some((m) => m.queueDepth > 0 || m.processingCount > 0)\n      }\n    }\n\n    await new Promise((resolve) => setTimeout(resolve, 100))\n  }\n\n  const subscribe = <TData>(\n    topic: string,\n    stepName: string,\n    handler: (event: Event<TData>) => void | Promise<void>,\n  ) => {\n    eventAdapter.subscribe(topic, stepName, handler)\n  }\n\n  return {\n    emit: eventAdapter.emit,\n    waitEvents,\n    subscribe,\n  }\n}\n"],"mappings":";;;AASA,MAAa,sBAAsB,iBAAiD;CAClF,MAAM,aAAa,YAAY;AAC7B,QAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;AAExD,MAAI,wBAAwB,0BAA0B;GACpD,IAAI,UAAU;AACd,UAAO,SAAS;AACd,UAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;IACxD,MAAMA,UAAwC,aAAa,eAAe;AAC1E,cAAU,OAAO,OAAO,QAAQ,CAAC,MAAM,MAAM,EAAE,aAAa,KAAK,EAAE,kBAAkB,EAAE;;;AAI3F,QAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;;CAG1D,MAAM,aACJ,OACA,UACA,YACG;AACH,eAAa,UAAU,OAAO,UAAU,QAAQ;;AAGlD,QAAO;EACL,MAAM,aAAa;EACnB;EACA;EACD"}

package/dist/helpers.d.mts

@@ -0,0 +1,17 @@
+import { MockFlowContext } from "./types.mjs";
+import { Logger } from "@motiadev/core";
+import { RedisClientType } from "redis";
+
+//#region src/helpers.d.ts
+declare const createMockLogger: () => jest.Mocked<Logger>;
+declare const setupLoggerMock: () => void;
+declare const createMockRedisClient: () => RedisClientType;
+declare const createMockContext: (options?: {
+  logger?: jest.Mocked<Logger>;
+  emit?: jest.Mock;
+  traceId?: string;
+  state?: Partial<MockFlowContext["state"]>;
+}) => MockFlowContext;
+//#endregion
+export { createMockContext, createMockLogger, createMockRedisClient, setupLoggerMock };
+//# sourceMappingURL=helpers.d.mts.map

package/dist/helpers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.mts","names":[],"sources":["../src/helpers.ts"],"sourcesContent":[],"mappings":";;;;;cAIa,wBAQU,IAAA,CAAK,OAAO;cAGtB;AAXA,cAeA,qBAPU,EAAA,GAAK,GAOa,eAPP;AAGrB,cAkCA,iBAhCZ,EAAA,CAAA,OAkCQ,CAlCR,EAAA;EAEY,MAAA,CAAA,EA+BF,IAAA,CAAK,MA/BH,CA+BU,MAHtB,CAAA;EAEY,IAAA,CAAA,EAEJ,IAAA,CAAK,IAFD;EACU,OAAA,CAAA,EAAA,MAAA;EAAZ,KAAK,CAAA,EAGN,OAHM,CAGE,eAHF,CAAA,OAAA,CAAA,CAAA;CACP,EAAA,GAGL,eAHU"}

package/dist/helpers.mjs

@@ -0,0 +1,64 @@
+import { Logger } from "@motiadev/core";
+
+//#region src/helpers.ts
+const createMockLogger = () => {
+	return {
+		info: jest.fn(),
+		error: jest.fn(),
+		warn: jest.fn(),
+		debug: jest.fn(),
+		log: jest.fn()
+	};
+};
+const setupLoggerMock = () => {
+	Logger.mockImplementation(createMockLogger);
+};
+const createMockRedisClient = () => {
+	return {
+		connect: jest.fn().mockResolvedValue(void 0),
+		quit: jest.fn().mockResolvedValue(void 0),
+		disconnect: jest.fn().mockResolvedValue(void 0),
+		isOpen: true,
+		on: jest.fn(),
+		get: jest.fn().mockResolvedValue(null),
+		set: jest.fn().mockResolvedValue("OK"),
+		del: jest.fn().mockResolvedValue(1),
+		exists: jest.fn().mockResolvedValue(1),
+		keys: jest.fn().mockResolvedValue([]),
+		flushAll: jest.fn().mockResolvedValue("OK"),
+		ping: jest.fn().mockResolvedValue("PONG"),
+		xAdd: jest.fn().mockResolvedValue(""),
+		xRead: jest.fn().mockResolvedValue([]),
+		xReadGroup: jest.fn().mockResolvedValue([]),
+		xGroupCreate: jest.fn().mockResolvedValue("OK"),
+		xAck: jest.fn().mockResolvedValue(1),
+		hGet: jest.fn().mockResolvedValue(null),
+		hSet: jest.fn().mockResolvedValue(1),
+		hGetAll: jest.fn().mockResolvedValue({}),
+		hDel: jest.fn().mockResolvedValue(1),
+		hExists: jest.fn().mockResolvedValue(0),
+		expire: jest.fn().mockResolvedValue(1),
+		ttl: jest.fn().mockResolvedValue(-1),
+		publish: jest.fn().mockResolvedValue(0)
+	};
+};
+const createMockContext = (options) => {
+	const { logger = createMockLogger(), emit = jest.fn(), traceId = "mock-trace-id", state } = options || {};
+	return {
+		logger,
+		emit,
+		traceId,
+		state: {
+			get: jest.fn(),
+			set: jest.fn(),
+			delete: jest.fn(),
+			clear: jest.fn(),
+			getGroup: jest.fn(),
+			...state
+		}
+	};
+};
+
+//#endregion
+export { createMockContext, createMockLogger, createMockRedisClient, setupLoggerMock };
+//# sourceMappingURL=helpers.mjs.map

package/dist/helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.mjs","names":[],"sources":["../src/helpers.ts"],"sourcesContent":["import { Logger } from '@motiadev/core'\nimport type { RedisClientType } from 'redis'\nimport type { MockFlowContext, MockLogger } from './types'\n\nexport const createMockLogger = () => {\n  const mockLogger: MockLogger = {\n    info: jest.fn(),\n    error: jest.fn(),\n    warn: jest.fn(),\n    debug: jest.fn(),\n    log: jest.fn(),\n  }\n  return mockLogger as jest.Mocked<Logger>\n}\n\nexport const setupLoggerMock = () => {\n  ;(Logger as jest.MockedClass<typeof Logger>).mockImplementation(createMockLogger)\n}\n\nexport const createMockRedisClient = (): RedisClientType => {\n  return {\n    connect: jest.fn().mockResolvedValue(undefined),\n    quit: jest.fn().mockResolvedValue(undefined),\n    disconnect: jest.fn().mockResolvedValue(undefined),\n    isOpen: true,\n    on: jest.fn(),\n    get: jest.fn().mockResolvedValue(null),\n    set: jest.fn().mockResolvedValue('OK'),\n    del: jest.fn().mockResolvedValue(1),\n    exists: jest.fn().mockResolvedValue(1),\n    keys: jest.fn().mockResolvedValue([]),\n    flushAll: jest.fn().mockResolvedValue('OK'),\n    ping: jest.fn().mockResolvedValue('PONG'),\n    xAdd: jest.fn().mockResolvedValue(''),\n    xRead: jest.fn().mockResolvedValue([]),\n    xReadGroup: jest.fn().mockResolvedValue([]),\n    xGroupCreate: jest.fn().mockResolvedValue('OK'),\n    xAck: jest.fn().mockResolvedValue(1),\n    hGet: jest.fn().mockResolvedValue(null),\n    hSet: jest.fn().mockResolvedValue(1),\n    hGetAll: jest.fn().mockResolvedValue({}),\n    hDel: jest.fn().mockResolvedValue(1),\n    hExists: jest.fn().mockResolvedValue(0),\n    expire: jest.fn().mockResolvedValue(1),\n    ttl: jest.fn().mockResolvedValue(-1),\n    publish: jest.fn().mockResolvedValue(0),\n  } as unknown as RedisClientType\n}\n\nexport const createMockContext = (options?: {\n  logger?: jest.Mocked<Logger>\n  emit?: jest.Mock\n  traceId?: string\n  state?: Partial<MockFlowContext['state']>\n}): MockFlowContext => {\n  const { logger = createMockLogger(), emit = jest.fn(), traceId = 'mock-trace-id', state } = options || {}\n\n  return {\n    logger,\n    emit,\n    traceId,\n    state: {\n      get: jest.fn(),\n      set: jest.fn(),\n      delete: jest.fn(),\n      clear: jest.fn(),\n      getGroup: jest.fn(),\n      ...state,\n    },\n  }\n}\n"],"mappings":";;;AAIA,MAAa,yBAAyB;AAQpC,QAP+B;EAC7B,MAAM,KAAK,IAAI;EACf,OAAO,KAAK,IAAI;EAChB,MAAM,KAAK,IAAI;EACf,OAAO,KAAK,IAAI;EAChB,KAAK,KAAK,IAAI;EACf;;AAIH,MAAa,wBAAwB;AAClC,CAAC,OAA2C,mBAAmB,iBAAiB;;AAGnF,MAAa,8BAA+C;AAC1D,QAAO;EACL,SAAS,KAAK,IAAI,CAAC,kBAAkB,OAAU;EAC/C,MAAM,KAAK,IAAI,CAAC,kBAAkB,OAAU;EAC5C,YAAY,KAAK,IAAI,CAAC,kBAAkB,OAAU;EAClD,QAAQ;EACR,IAAI,KAAK,IAAI;EACb,KAAK,KAAK,IAAI,CAAC,kBAAkB,KAAK;EACtC,KAAK,KAAK,IAAI,CAAC,kBAAkB,KAAK;EACtC,KAAK,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACnC,QAAQ,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACtC,MAAM,KAAK,IAAI,CAAC,kBAAkB,EAAE,CAAC;EACrC,UAAU,KAAK,IAAI,CAAC,kBAAkB,KAAK;EAC3C,MAAM,KAAK,IAAI,CAAC,kBAAkB,OAAO;EACzC,MAAM,KAAK,IAAI,CAAC,kBAAkB,GAAG;EACrC,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE,CAAC;EACtC,YAAY,KAAK,IAAI,CAAC,kBAAkB,EAAE,CAAC;EAC3C,cAAc,KAAK,IAAI,CAAC,kBAAkB,KAAK;EAC/C,MAAM,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACpC,MAAM,KAAK,IAAI,CAAC,kBAAkB,KAAK;EACvC,MAAM,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACpC,SAAS,KAAK,IAAI,CAAC,kBAAkB,EAAE,CAAC;EACxC,MAAM,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACpC,SAAS,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACvC,QAAQ,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACtC,KAAK,KAAK,IAAI,CAAC,kBAAkB,GAAG;EACpC,SAAS,KAAK,IAAI,CAAC,kBAAkB,EAAE;EACxC;;AAGH,MAAa,qBAAqB,YAKX;CACrB,MAAM,EAAE,SAAS,kBAAkB,EAAE,OAAO,KAAK,IAAI,EAAE,UAAU,iBAAiB,UAAU,WAAW,EAAE;AAEzG,QAAO;EACL;EACA;EACA;EACA,OAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,QAAQ,KAAK,IAAI;GACjB,OAAO,KAAK,IAAI;GAChB,UAAU,KAAK,IAAI;GACnB,GAAG;GACJ;EACF"}

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { createEventManager } from "./event-manager.mjs";
+import { CapturedEvent, MockFlowContext, MockLogger, MotiaTester, RequestOptions, Watcher } from "./types.mjs";
+import { createMockContext, createMockLogger, createMockRedisClient, setupLoggerMock } from "./helpers.mjs";
+import { createMotiaTester } from "./tester.mjs";
+export { CapturedEvent, MockFlowContext, MockLogger, MotiaTester, RequestOptions, Watcher, createEventManager, createMockContext, createMockLogger, createMockRedisClient, createMotiaTester, setupLoggerMock };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { createEventManager } from "./event-manager.mjs";
+import { createMockContext, createMockLogger, createMockRedisClient, setupLoggerMock } from "./helpers.mjs";
+import { createMotiaTester } from "./tester.mjs";
+
+export { createEventManager, createMockContext, createMockLogger, createMockRedisClient, createMotiaTester, setupLoggerMock };

package/dist/tester.d.mts

@@ -0,0 +1,7 @@
+import { MotiaTester } from "./types.mjs";
+
+//#region src/tester.d.ts
+declare const createMotiaTester: () => MotiaTester;
+//#endregion
+export { createMotiaTester };
+//# sourceMappingURL=tester.d.mts.map

package/dist/tester.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tester.d.mts","names":[],"sources":["../src/tester.ts"],"sourcesContent":[],"mappings":";;;cAgBa,yBAAwB"}

package/dist/tester.mjs

@@ -0,0 +1,58 @@
+import { createEventManager } from "./event-manager.mjs";
+import { createMockRedisClient } from "./helpers.mjs";
+import { DefaultCronAdapter, DefaultQueueEventAdapter, Logger, MemoryStreamAdapterManager, createServer, createStateAdapter } from "@motiadev/core";
+import { generateLockedData } from "motia";
+import path from "path";
+import request from "supertest";
+
+//#region src/tester.ts
+const createMotiaTester = () => {
+	const eventAdapter = new DefaultQueueEventAdapter();
+	const eventManager = createEventManager(eventAdapter);
+	const logger = new Logger();
+	const promise = (async () => {
+		const lockedData = await generateLockedData({
+			projectDir: path.join(process.cwd()),
+			streamAdapter: new MemoryStreamAdapterManager(),
+			printerType: "disabled",
+			redisClient: createMockRedisClient()
+		});
+		const state = createStateAdapter({ adapter: "memory" });
+		const { server, socketServer, close } = createServer(lockedData, state, { isVerbose: false }, {
+			eventAdapter,
+			cronAdapter: new DefaultCronAdapter()
+		});
+		return {
+			server,
+			socketServer,
+			eventManager,
+			state,
+			close
+		};
+	})();
+	return {
+		logger,
+		waitEvents: async () => promise.then(({ eventManager: eventManager$1 }) => eventManager$1.waitEvents()),
+		post: async (path$1, options) => promise.then(({ server }) => request(server).post(path$1).send(options.body)),
+		get: async (path$1, options) => promise.then(({ server }) => request(server).get(path$1).send(options.body)),
+		emit: async (event) => eventManager.emit(event),
+		watch: async (event) => {
+			const events = [];
+			eventManager.subscribe(event, "$watcher", async (event$1) => {
+				const { logger: logger$1, tracer, ...rest } = event$1;
+				events.push(rest);
+			});
+			return {
+				getCapturedEvents: () => events,
+				getLastCapturedEvent: () => events[events.length - 1],
+				getCapturedEvent: (index) => events[index]
+			};
+		},
+		sleep: async (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+		close: async () => promise.then(({ close }) => close())
+	};
+};
+
+//#endregion
+export { createMotiaTester };
+//# sourceMappingURL=tester.mjs.map

package/dist/tester.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tester.mjs","names":["eventManager","path","events: CapturedEvent<TData>[]","event"],"sources":["../src/tester.ts"],"sourcesContent":["import {\n  createServer,\n  createStateAdapter,\n  DefaultCronAdapter,\n  DefaultQueueEventAdapter,\n  type Event,\n  Logger,\n  MemoryStreamAdapterManager,\n} from '@motiadev/core'\nimport { generateLockedData } from 'motia'\nimport path from 'path'\nimport request from 'supertest'\nimport { createEventManager } from './event-manager'\nimport { createMockRedisClient } from './helpers'\nimport type { CapturedEvent, MotiaTester } from './types'\n\nexport const createMotiaTester = (): MotiaTester => {\n  const eventAdapter = new DefaultQueueEventAdapter()\n  const eventManager = createEventManager(eventAdapter)\n  const logger = new Logger()\n\n  const promise = (async () => {\n    const lockedData = await generateLockedData({\n      projectDir: path.join(process.cwd()),\n      streamAdapter: new MemoryStreamAdapterManager(),\n      printerType: 'disabled',\n      redisClient: createMockRedisClient(),\n    })\n    const state = createStateAdapter({ adapter: 'memory' })\n    const { server, socketServer, close } = createServer(\n      lockedData,\n      state,\n      { isVerbose: false },\n      { eventAdapter, cronAdapter: new DefaultCronAdapter() },\n    )\n\n    return { server, socketServer, eventManager, state, close }\n  })()\n\n  return {\n    logger,\n    waitEvents: async () => promise.then(({ eventManager }) => eventManager.waitEvents()),\n    post: async (path, options) => promise.then(({ server }) => request(server).post(path).send(options.body)),\n    get: async (path, options) => promise.then(({ server }) => request(server).get(path).send(options.body)),\n    emit: async (event) => eventManager.emit(event),\n    watch: async <TData>(event: string) => {\n      const events: CapturedEvent<TData>[] = []\n\n      eventManager.subscribe(event, '$watcher', async (event: Event<TData>) => {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const { logger, tracer, ...rest } = event\n        events.push(rest)\n      })\n\n      return {\n        getCapturedEvents: () => events,\n        getLastCapturedEvent: () => events[events.length - 1],\n        getCapturedEvent: (index) => events[index],\n      }\n    },\n    sleep: async (ms) => new Promise((resolve) => setTimeout(resolve, ms)),\n    close: async () => promise.then(({ close }) => close()),\n  }\n}\n"],"mappings":";;;;;;;;AAgBA,MAAa,0BAAuC;CAClD,MAAM,eAAe,IAAI,0BAA0B;CACnD,MAAM,eAAe,mBAAmB,aAAa;CACrD,MAAM,SAAS,IAAI,QAAQ;CAE3B,MAAM,WAAW,YAAY;EAC3B,MAAM,aAAa,MAAM,mBAAmB;GAC1C,YAAY,KAAK,KAAK,QAAQ,KAAK,CAAC;GACpC,eAAe,IAAI,4BAA4B;GAC/C,aAAa;GACb,aAAa,uBAAuB;GACrC,CAAC;EACF,MAAM,QAAQ,mBAAmB,EAAE,SAAS,UAAU,CAAC;EACvD,MAAM,EAAE,QAAQ,cAAc,UAAU,aACtC,YACA,OACA,EAAE,WAAW,OAAO,EACpB;GAAE;GAAc,aAAa,IAAI,oBAAoB;GAAE,CACxD;AAED,SAAO;GAAE;GAAQ;GAAc;GAAc;GAAO;GAAO;KACzD;AAEJ,QAAO;EACL;EACA,YAAY,YAAY,QAAQ,MAAM,EAAE,mCAAmBA,eAAa,YAAY,CAAC;EACrF,MAAM,OAAO,QAAM,YAAY,QAAQ,MAAM,EAAE,aAAa,QAAQ,OAAO,CAAC,KAAKC,OAAK,CAAC,KAAK,QAAQ,KAAK,CAAC;EAC1G,KAAK,OAAO,QAAM,YAAY,QAAQ,MAAM,EAAE,aAAa,QAAQ,OAAO,CAAC,IAAIA,OAAK,CAAC,KAAK,QAAQ,KAAK,CAAC;EACxG,MAAM,OAAO,UAAU,aAAa,KAAK,MAAM;EAC/C,OAAO,OAAc,UAAkB;GACrC,MAAMC,SAAiC,EAAE;AAEzC,gBAAa,UAAU,OAAO,YAAY,OAAO,YAAwB;IAEvE,MAAM,EAAE,kBAAQ,QAAQ,GAAG,SAASC;AACpC,WAAO,KAAK,KAAK;KACjB;AAEF,UAAO;IACL,yBAAyB;IACzB,4BAA4B,OAAO,OAAO,SAAS;IACnD,mBAAmB,UAAU,OAAO;IACrC;;EAEH,OAAO,OAAO,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;EACtE,OAAO,YAAY,QAAQ,MAAM,EAAE,YAAY,OAAO,CAAC;EACxD"}

package/dist/types.d.mts

@@ -0,0 +1,41 @@
+import { Event, FlowContext, InternalStateManager, Logger } from "@motiadev/core";
+import { Response } from "supertest";
+
+//#region src/types.d.ts
+type Watcher<TData = unknown> = {
+  getCapturedEvents(): CapturedEvent<TData>[];
+  getLastCapturedEvent(): CapturedEvent<TData> | undefined;
+  getCapturedEvent(index: number): CapturedEvent<TData> | undefined;
+};
+interface MotiaTester {
+  post(path: string, options: RequestOptions): Promise<Response>;
+  get(path: string, options: RequestOptions): Promise<Response>;
+  emit(event: Event): Promise<void>;
+  watch<TData>(event: string): Promise<Watcher<TData>>;
+  sleep(ms: number): Promise<void>;
+  close(): Promise<void>;
+  waitEvents(): Promise<void>;
+  logger: Logger;
+}
+type RequestOptions = {
+  body?: Record<string, unknown>;
+  headers?: Record<string, string>;
+  cookies?: Record<string, string>;
+};
+type CapturedEvent<TData = unknown> = Omit<Event<TData>, 'logger' | 'tracer'>;
+type MockFlowContext = {
+  logger: jest.Mocked<Logger>;
+  emit: jest.Mock | FlowContext<unknown>['emit'];
+  traceId: string;
+  state: jest.Mocked<InternalStateManager>;
+};
+interface MockLogger {
+  info: (message: string) => void;
+  debug: (message: string) => void;
+  warn: (message: string) => void;
+  error: (message: string) => void;
+  log: (message: string) => void;
+}
+//#endregion
+export { CapturedEvent, MockFlowContext, MockLogger, MotiaTester, RequestOptions, Watcher };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;KAGY;uBACW,cAAc;EADzB,oBAAO,EAAA,EAEO,aAFP,CAEqB,KAFrB,CAAA,GAAA,SAAA;EACkB,gBAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAEF,aAFE,CAEY,KAFZ,CAAA,GAAA,SAAA;CAAd;AACiB,UAIvB,WAAA,CAJuB;EAAd,IAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAKI,cALJ,CAAA,EAKqB,OALrB,CAK6B,QAL7B,CAAA;EACuB,GAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAKpB,cALoB,CAAA,EAKH,OALG,CAKK,QALL,CAAA;EAAd,IAAA,CAAA,KAAA,EAMrB,KANqB,CAAA,EAMb,OANa,CAAA,IAAA,CAAA;EAAa,KAAA,CAAA,KAAA,CAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAOjB,OAPiB,CAOT,OAPS,CAOD,KAPC,CAAA,CAAA;EAG/B,KAAA,CAAA,EAAA,EAAA,MAAW,CAAA,EAKP,OALO,CAAA,IAAA,CAAA;EACE,KAAA,EAAA,EAKnB,OALmB,CAAA,IAAA,CAAA;EAAyB,UAAA,EAAA,EAMvC,OANuC,CAAA,IAAA,CAAA;EAAR,MAAA,EAOrC,MAPqC;;AACO,KAS1C,cAAA,GAT0C;EAAR,IAAA,CAAA,EAUrC,MAVqC,CAAA,MAAA,EAAA,OAAA,CAAA;EAChC,OAAA,CAAA,EAUF,MAVE,CAAA,MAAA,EAAA,MAAA,CAAA;EAAQ,OAAA,CAAA,EAWV,MAXU,CAAA,MAAA,EAAA,MAAA,CAAA;CACyB;AAAR,KAa3B,aAb2B,CAAA,QAAA,OAAA,CAAA,GAaM,IAbN,CAaW,KAbX,CAaiB,KAbjB,CAAA,EAAA,QAAA,GAAA,QAAA,CAAA;AAAR,KAenB,eAAA,GAfmB;EACV,MAAA,EAeX,IAAA,CAAK,MAfM,CAeC,MAfD,CAAA;EACV,IAAA,EAeH,IAAA,CAAK,IAfF,GAeS,WAfT,CAAA,OAAA,CAAA,CAAA,MAAA,CAAA;EACK,OAAA,EAAA,MAAA;EACN,KAAA,EAeD,IAAA,CAAK,MAfJ,CAeW,oBAfX,CAAA;CAAM;AAGJ,UAeK,UAAA,CAfS;EACjB,IAAA,EAAA,CAAA,OAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EACG,KAAA,EAAA,CAAA,OAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EACA,IAAA,EAAA,CAAA,OAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAAM,KAAA,EAAA,CAAA,OAAA,EAAA,MAAA,EAAA,GAAA,IAAA;EAGN,GAAA,EAAA,CAAA,OAAA,EAAA,MAAa,EAAA,GAAA,IAAA"}

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@motiadev/test",
   "description": "A testing utility package for Motia workflows that provides tools for mocking, testing, and simulating Motia components.",
-  "version": "0.13.2-beta.163",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "type": "module",
+  "version": "0.13.2-beta.164-562802",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
   "peerDependencies": {
-    "@motiadev/core": "0.13.2-beta.163",
-    "motia": "0.13.2-beta.163"
+    "@motiadev/core": "0.13.2-beta.164-562802",
+    "motia": "0.13.2-beta.164-562802"
   },
   "dependencies": {
     "jest": "^29.7.0",
@@ -18,10 +20,13 @@
     "@types/supertest": "^6.0.2",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
+    "tsdown": "^0.16.6",
     "typescript": "^5.7.2"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
-    "lint": "eslint --config ../../eslint.config.js"
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "eslint --config ../../eslint.config.js",
+    "clean": "rm -rf dist"
   }
 }

package/tsdown.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: {
+    index: './src/index.ts',
+  },
+  format: 'esm',
+  platform: 'node',
+  external: ['@motiadev/core', 'motia', 'jest', 'redis', 'supertest'],
+  dts: {
+    build: true,
+  },
+  clean: true,
+  outDir: 'dist',
+  sourcemap: true,
+  unbundle: true,
+})

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from './src/event-manager';
-export * from './src/helpers';
-export * from './src/tester';
-export * from './src/types';

package/dist/index.js

@@ -1,20 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/event-manager"), exports);
-__exportStar(require("./src/helpers"), exports);
-__exportStar(require("./src/tester"), exports);
-__exportStar(require("./src/types"), exports);

package/dist/src/event-manager.d.ts

@@ -1,8 +0,0 @@
-import type { Event, EventAdapter } from '@motiadev/core';
-interface TestEventManager {
-    emit: <TData>(event: Event<TData>, file?: string) => Promise<void>;
-    waitEvents(): Promise<void>;
-    subscribe: <TData>(topic: string, stepName: string, handler: (event: Event<TData>) => void | Promise<void>) => void;
-}
-export declare const createEventManager: (eventAdapter: EventAdapter) => TestEventManager;
-export {};

package/dist/src/event-manager.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEventManager = void 0;
-const core_1 = require("@motiadev/core");
-const createEventManager = (eventAdapter) => {
-    const waitEvents = async () => {
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        if (eventAdapter instanceof core_1.DefaultQueueEventAdapter) {
-            let hasWork = true;
-            while (hasWork) {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                const metrics = eventAdapter.getAllMetrics();
-                hasWork = Object.values(metrics).some((m) => m.queueDepth > 0 || m.processingCount > 0);
-            }
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    };
-    const subscribe = (topic, stepName, handler) => {
-        eventAdapter.subscribe(topic, stepName, handler);
-    };
-    return {
-        emit: eventAdapter.emit,
-        waitEvents,
-        subscribe,
-    };
-};
-exports.createEventManager = createEventManager;

package/dist/src/helpers.d.ts

@@ -1,12 +0,0 @@
-import { Logger } from '@motiadev/core';
-import type { RedisClientType } from 'redis';
-import type { MockFlowContext } from './types';
-export declare const createMockLogger: () => jest.Mocked<Logger>;
-export declare const setupLoggerMock: () => void;
-export declare const createMockRedisClient: () => RedisClientType;
-export declare const createMockContext: (options?: {
-    logger?: jest.Mocked<Logger>;
-    emit?: jest.Mock;
-    traceId?: string;
-    state?: Partial<MockFlowContext["state"]>;
-}) => MockFlowContext;

package/dist/src/helpers.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMockContext = exports.createMockRedisClient = exports.setupLoggerMock = exports.createMockLogger = void 0;
-const core_1 = require("@motiadev/core");
-const createMockLogger = () => {
-    const mockLogger = {
-        info: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn(),
-        debug: jest.fn(),
-        log: jest.fn(),
-    };
-    return mockLogger;
-};
-exports.createMockLogger = createMockLogger;
-const setupLoggerMock = () => {
-    ;
-    core_1.Logger.mockImplementation(exports.createMockLogger);
-};
-exports.setupLoggerMock = setupLoggerMock;
-const createMockRedisClient = () => {
-    return {
-        connect: jest.fn().mockResolvedValue(undefined),
-        quit: jest.fn().mockResolvedValue(undefined),
-        disconnect: jest.fn().mockResolvedValue(undefined),
-        isOpen: true,
-        on: jest.fn(),
-        get: jest.fn().mockResolvedValue(null),
-        set: jest.fn().mockResolvedValue('OK'),
-        del: jest.fn().mockResolvedValue(1),
-        exists: jest.fn().mockResolvedValue(1),
-        keys: jest.fn().mockResolvedValue([]),
-        flushAll: jest.fn().mockResolvedValue('OK'),
-        ping: jest.fn().mockResolvedValue('PONG'),
-        xAdd: jest.fn().mockResolvedValue(''),
-        xRead: jest.fn().mockResolvedValue([]),
-        xReadGroup: jest.fn().mockResolvedValue([]),
-        xGroupCreate: jest.fn().mockResolvedValue('OK'),
-        xAck: jest.fn().mockResolvedValue(1),
-        hGet: jest.fn().mockResolvedValue(null),
-        hSet: jest.fn().mockResolvedValue(1),
-        hGetAll: jest.fn().mockResolvedValue({}),
-        hDel: jest.fn().mockResolvedValue(1),
-        hExists: jest.fn().mockResolvedValue(0),
-        expire: jest.fn().mockResolvedValue(1),
-        ttl: jest.fn().mockResolvedValue(-1),
-        publish: jest.fn().mockResolvedValue(0),
-    };
-};
-exports.createMockRedisClient = createMockRedisClient;
-const createMockContext = (options) => {
-    const { logger = (0, exports.createMockLogger)(), emit = jest.fn(), traceId = 'mock-trace-id', state } = options || {};
-    return {
-        logger,
-        emit,
-        traceId,
-        state: {
-            get: jest.fn(),
-            set: jest.fn(),
-            delete: jest.fn(),
-            clear: jest.fn(),
-            getGroup: jest.fn(),
-            ...state,
-        },
-    };
-};
-exports.createMockContext = createMockContext;

package/dist/src/tester.d.ts

@@ -1,2 +0,0 @@
-import type { MotiaTester } from './types';
-export declare const createMotiaTester: () => MotiaTester;

package/dist/src/tester.js

@@ -1,51 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMotiaTester = void 0;
-const core_1 = require("@motiadev/core");
-const motia_1 = require("motia");
-const path_1 = __importDefault(require("path"));
-const supertest_1 = __importDefault(require("supertest"));
-const event_manager_1 = require("./event-manager");
-const helpers_1 = require("./helpers");
-const createMotiaTester = () => {
-    const eventAdapter = new core_1.DefaultQueueEventAdapter();
-    const eventManager = (0, event_manager_1.createEventManager)(eventAdapter);
-    const logger = new core_1.Logger();
-    const promise = (async () => {
-        const lockedData = await (0, motia_1.generateLockedData)({
-            projectDir: path_1.default.join(process.cwd()),
-            streamAdapter: new core_1.MemoryStreamAdapterManager(),
-            printerType: 'disabled',
-            redisClient: (0, helpers_1.createMockRedisClient)(),
-        });
-        const state = (0, core_1.createStateAdapter)({ adapter: 'memory' });
-        const { server, socketServer, close } = (0, core_1.createServer)(lockedData, state, { isVerbose: false }, { eventAdapter, cronAdapter: new core_1.DefaultCronAdapter() });
-        return { server, socketServer, eventManager, state, close };
-    })();
-    return {
-        logger,
-        waitEvents: async () => promise.then(({ eventManager }) => eventManager.waitEvents()),
-        post: async (path, options) => promise.then(({ server }) => (0, supertest_1.default)(server).post(path).send(options.body)),
-        get: async (path, options) => promise.then(({ server }) => (0, supertest_1.default)(server).get(path).send(options.body)),
-        emit: async (event) => eventManager.emit(event),
-        watch: async (event) => {
-            const events = [];
-            eventManager.subscribe(event, '$watcher', async (event) => {
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const { logger, tracer, ...rest } = event;
-                events.push(rest);
-            });
-            return {
-                getCapturedEvents: () => events,
-                getLastCapturedEvent: () => events[events.length - 1],
-                getCapturedEvent: (index) => events[index],
-            };
-        },
-        sleep: async (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-        close: async () => promise.then(({ close }) => close()),
-    };
-};
-exports.createMotiaTester = createMotiaTester;

package/dist/src/types.d.ts

@@ -1,36 +0,0 @@
-import type { Event, FlowContext, InternalStateManager, Logger } from '@motiadev/core';
-import type { Response } from 'supertest';
-export type Watcher<TData = unknown> = {
-    getCapturedEvents(): CapturedEvent<TData>[];
-    getLastCapturedEvent(): CapturedEvent<TData> | undefined;
-    getCapturedEvent(index: number): CapturedEvent<TData> | undefined;
-};
-export interface MotiaTester {
-    post(path: string, options: RequestOptions): Promise<Response>;
-    get(path: string, options: RequestOptions): Promise<Response>;
-    emit(event: Event): Promise<void>;
-    watch<TData>(event: string): Promise<Watcher<TData>>;
-    sleep(ms: number): Promise<void>;
-    close(): Promise<void>;
-    waitEvents(): Promise<void>;
-    logger: Logger;
-}
-export type RequestOptions = {
-    body?: Record<string, unknown>;
-    headers?: Record<string, string>;
-    cookies?: Record<string, string>;
-};
-export type CapturedEvent<TData = unknown> = Omit<Event<TData>, 'logger' | 'tracer'>;
-export type MockFlowContext = {
-    logger: jest.Mocked<Logger>;
-    emit: jest.Mock | FlowContext<unknown>['emit'];
-    traceId: string;
-    state: jest.Mocked<InternalStateManager>;
-};
-export interface MockLogger {
-    info: (message: string) => void;
-    debug: (message: string) => void;
-    warn: (message: string) => void;
-    error: (message: string) => void;
-    log: (message: string) => void;
-}

package/dist/src/types.js

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