@motiadev/test 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createMotiaTester } from './src/tester';
+export { CapturedEvent } from './src/types';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMotiaTester = void 0;
+var tester_1 = require("./src/tester");
+Object.defineProperty(exports, "createMotiaTester", { enumerable: true, get: function () { return tester_1.createMotiaTester; } });

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

@@ -0,0 +1,6 @@
+import { EventManager } from '@motiadev/core';
+interface TestEventManager extends EventManager {
+    waitEvents(): Promise<void>;
+}
+export declare const createEventManager: () => TestEventManager;
+export {};

package/dist/src/event-manager.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventManager = void 0;
+const createEventManager = () => {
+    const handlers = {};
+    const events = [];
+    const waitEvents = async () => {
+        let eventsToAwait = [...events];
+        // We need to wait for all events to be resolved because the event manager is async
+        // and we need to ensure that all events have been processed before we can continue
+        while (eventsToAwait.length > 0) {
+            events.splice(0, eventsToAwait.length);
+            await Promise.allSettled(eventsToAwait);
+            eventsToAwait = [...events];
+        }
+    };
+    const emit = async (event) => {
+        const eventHandlers = handlers[event.type] ?? [];
+        events.push(...eventHandlers.map((handler) => handler(event)));
+    };
+    const subscribe = (event, _, handler) => {
+        if (!handlers[event]) {
+            handlers[event] = [];
+        }
+        handlers[event].push(handler);
+    };
+    return { emit, subscribe, waitEvents };
+};
+exports.createEventManager = createEventManager;

package/dist/src/tester.d.ts

@@ -0,0 +1,19 @@
+import { Response } from 'supertest';
+import { Event } from '@motiadev/core';
+import { CapturedEvent, RequestOptions } from './types';
+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<any>): Promise<void>;
+    watch<TData>(event: string): Promise<Watcher<TData>>;
+    sleep(ms: number): Promise<void>;
+    close(): Promise<void>;
+    waitEvents(): Promise<void>;
+}
+export declare const createMotiaTester: () => MotiaTester;
+export {};

package/dist/src/tester.js

@@ -0,0 +1,69 @@
+"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 supertest_1 = __importDefault(require("supertest"));
+const core_1 = require("@motiadev/core");
+const generate_locked_data_1 = require("@motiadev/snap/src/generate-locked-data");
+const event_manager_1 = require("./event-manager");
+const path_1 = __importDefault(require("path"));
+const createMotiaTester = () => {
+    const eventManager = (0, event_manager_1.createEventManager)();
+    const promise = (async () => {
+        const lockedData = await (0, generate_locked_data_1.generateLockedData)(path_1.default.join(process.cwd()));
+        const steps = [...lockedData.steps.active, ...lockedData.steps.dev];
+        const state = (0, core_1.createStateAdapter)({
+            adapter: 'default',
+            filePath: path_1.default.join(process.cwd(), '.motia'),
+        });
+        const { server, socketServer } = await (0, core_1.createServer)({
+            steps,
+            flows: lockedData.flows,
+            state,
+            eventManager,
+        });
+        (0, core_1.createStepHandlers)(steps, eventManager, state);
+        return { server, socketServer, eventManager, state };
+    })();
+    return {
+        waitEvents: async () => {
+            const { eventManager } = await promise;
+            await eventManager.waitEvents();
+        },
+        post: async (path, options) => {
+            const { server } = await promise;
+            return (0, supertest_1.default)(server).post(path).send(options.body);
+        },
+        get: async (path, options) => {
+            const { server } = await promise;
+            return (0, supertest_1.default)(server).get(path).send(options.body);
+        },
+        emit: async (event) => {
+            return eventManager.emit(event);
+        },
+        watch: async (event) => {
+            const events = [];
+            eventManager.subscribe(event, '$watcher', async (event) => {
+                const { logger, ...rest } = event;
+                events.push(rest);
+            });
+            return {
+                getCapturedEvents: () => events,
+                getLastCapturedEvent: () => events[events.length - 1],
+                getCapturedEvent: (index) => events[index],
+            };
+        },
+        sleep: async (ms) => {
+            return new Promise((resolve) => setTimeout(resolve, ms));
+        },
+        close: async () => {
+            const { server, socketServer, state } = await promise;
+            await state.cleanup();
+            await socketServer.close();
+            server.close();
+        },
+    };
+};
+exports.createMotiaTester = createMotiaTester;

package/dist/src/types.d.ts

@@ -0,0 +1,5 @@
+import type { Event } from '@motiadev/core';
+export type RequestOptions = {
+    body?: Record<string, unknown>;
+};
+export type CapturedEvent<TData = unknown> = Omit<Event<TData>, 'logger'>;

package/dist/src/types.js

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

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@motiadev/test",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "peerDependencies": {
+    "@motiadev/core": "0.0.1",
+    "@motiadev/snap": "0.0.1"
+  },
+  "dependencies": {
+    "supertest": "^7.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/supertest": "^6.0.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc"
+  }
+}