motia 0.11.1-beta.155 → 0.11.1-beta.156-879726

package/dist/cjs/__tests__/redis-memory-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/__tests__/redis-memory-manager.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const redis_1 = require("redis");
+const redis_memory_server_1 = require("redis-memory-server");
+const redis_memory_manager_1 = require("../redis-memory-manager");
+jest.mock('fs');
+jest.mock('redis');
+jest.mock('redis-memory-server');
+const mockMkdirSync = fs_1.mkdirSync;
+const mockCreateClient = redis_1.createClient;
+const mockRedisMemoryServer = redis_memory_server_1.RedisMemoryServer;
+describe('redis-memory-manager', () => {
+    let mockRedisClient;
+    let mockServerInstance;
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env = { ...originalEnv };
+        mockRedisClient = {
+            connect: jest.fn().mockResolvedValue(undefined),
+            quit: jest.fn().mockResolvedValue(undefined),
+            isOpen: true,
+            on: jest.fn(),
+        };
+        mockServerInstance = {
+            getHost: jest.fn().mockResolvedValue('127.0.0.1'),
+            getPort: jest.fn().mockResolvedValue(6379),
+            stop: jest.fn().mockResolvedValue(undefined),
+        };
+        mockCreateClient.mockReturnValue(mockRedisClient);
+        mockRedisMemoryServer.mockImplementation(() => mockServerInstance);
+    });
+    afterEach(async () => {
+        await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+        process.env = originalEnv;
+    });
+    describe('instanceRedisMemoryServer', () => {
+        it('should start Redis server and return client', async () => {
+            const baseDir = '/test/dir';
+            const client = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            expect(mockMkdirSync).toHaveBeenCalledWith(baseDir, { recursive: true });
+            expect(mockRedisMemoryServer).toHaveBeenCalledWith({
+                instance: {
+                    ip: '127.0.0.1',
+                    args: ['--appendonly', 'yes', '--save', '900 1', '--save', '300 10', '--save', '60 100', '--dir', baseDir],
+                },
+                autoStart: true,
+            });
+            expect(mockServerInstance.getHost).toHaveBeenCalled();
+            expect(mockServerInstance.getPort).toHaveBeenCalled();
+            expect(mockCreateClient).toHaveBeenCalledWith({
+                socket: {
+                    host: '127.0.0.1',
+                    port: 6379,
+                    reconnectStrategy: expect.any(Function),
+                    connectTimeout: 10000,
+                },
+            });
+            expect(mockRedisClient.connect).toHaveBeenCalled();
+            expect(client).toBe(mockRedisClient);
+        });
+        it('should use custom host from environment variable', async () => {
+            process.env.MOTIA_REDIS_HOST = '192.168.1.1';
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, false);
+            expect(mockRedisMemoryServer).toHaveBeenCalledWith({
+                instance: expect.objectContaining({
+                    ip: '192.168.1.1',
+                }),
+                autoStart: false,
+            });
+        });
+        it('should use custom port from environment variable', async () => {
+            process.env.MOTIA_REDIS_PORT = '6380';
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            expect(mockRedisMemoryServer).toHaveBeenCalledWith({
+                instance: expect.objectContaining({
+                    port: 6380,
+                }),
+                autoStart: true,
+            });
+        });
+        it('should return existing client if already running', async () => {
+            const baseDir = '/test/dir';
+            const client1 = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const client2 = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, false);
+            expect(client1).toBe(client2);
+            expect(mockRedisMemoryServer).toHaveBeenCalledTimes(1);
+            expect(mockCreateClient).toHaveBeenCalledTimes(1);
+        });
+        it('should set up error handler on client', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            expect(mockRedisClient.on).toHaveBeenCalledWith('error', expect.any(Function));
+        });
+        it('should handle connection errors', async () => {
+            const baseDir = '/test/dir';
+            const error = new Error('Connection failed');
+            mockRedisClient.connect.mockRejectedValue(error);
+            await expect((0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true)).rejects.toThrow('Connection failed');
+        });
+        it('should handle server start errors', async () => {
+            const baseDir = '/test/dir';
+            const error = new Error('Server start failed');
+            mockServerInstance.getHost.mockRejectedValue(error);
+            await expect((0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true)).rejects.toThrow('Server start failed');
+        });
+        it('should implement reconnect strategy correctly', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const callArgs = mockCreateClient.mock.calls[0];
+            expect(callArgs).toBeDefined();
+            const socketConfig = callArgs?.[0]?.socket;
+            expect(socketConfig).toBeDefined();
+            const reconnectStrategy = socketConfig?.reconnectStrategy;
+            expect(reconnectStrategy).toBeDefined();
+            expect(typeof reconnectStrategy).toBe('function');
+            if (reconnectStrategy && typeof reconnectStrategy === 'function') {
+                const mockError = new Error('test');
+                expect(reconnectStrategy(5, mockError)).toBe(500);
+                expect(reconnectStrategy(10, mockError)).toBe(1000);
+                expect(reconnectStrategy(11, mockError)).toBeInstanceOf(Error);
+                expect(reconnectStrategy(11, mockError).message).toBe('Redis connection retry limit exceeded');
+                expect(reconnectStrategy(15, mockError)).toBeInstanceOf(Error);
+                expect(reconnectStrategy(20, mockError)).toBeInstanceOf(Error);
+                expect(reconnectStrategy(30, mockError)).toBeInstanceOf(Error);
+                expect(reconnectStrategy(50, mockError)).toBeInstanceOf(Error);
+            }
+        });
+    });
+    describe('stopRedisMemoryServer', () => {
+        it('should stop Redis server and close client', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).toHaveBeenCalled();
+            expect(mockServerInstance.stop).toHaveBeenCalled();
+        });
+        it('should handle client close errors gracefully', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const error = new Error('Close failed');
+            mockRedisClient.quit.mockRejectedValue(error);
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).toHaveBeenCalled();
+            expect(mockServerInstance.stop).toHaveBeenCalled();
+        });
+        it('should handle server stop errors gracefully', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const error = new Error('Stop failed');
+            mockServerInstance.stop.mockRejectedValue(error);
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).toHaveBeenCalled();
+            expect(mockServerInstance.stop).toHaveBeenCalled();
+        });
+        it('should not throw if client is not open', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            Object.defineProperty(mockRedisClient, 'isOpen', {
+                value: false,
+                writable: true,
+                configurable: true,
+            });
+            await expect((0, redis_memory_manager_1.stopRedisMemoryServer)()).resolves.not.toThrow();
+        });
+        it('should do nothing if server is not running', async () => {
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).not.toHaveBeenCalled();
+            expect(mockServerInstance.stop).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/cjs/__tests__/test-helpers/redis-test-helper.d.ts

@@ -0,0 +1,51 @@
+export interface MockRedisClient {
+    connect: jest.Mock<Promise<void>>;
+    quit: jest.Mock<Promise<void>>;
+    disconnect: jest.Mock<Promise<void>>;
+    isOpen: boolean;
+    on: jest.Mock;
+    get: jest.Mock<Promise<string | null>>;
+    set: jest.Mock<Promise<string | null>>;
+    del: jest.Mock<Promise<number>>;
+    exists: jest.Mock<Promise<number>>;
+    keys: jest.Mock<Promise<string[]>>;
+    flushAll: jest.Mock<Promise<string>>;
+    ping: jest.Mock<Promise<string>>;
+    xAdd: jest.Mock<Promise<string>>;
+    xRead: jest.Mock<Promise<unknown[]>>;
+    xReadGroup: jest.Mock<Promise<unknown[]>>;
+    xGroupCreate: jest.Mock<Promise<string>>;
+    xAck: jest.Mock<Promise<number>>;
+    hGet: jest.Mock<Promise<string | null>>;
+    hSet: jest.Mock<Promise<number>>;
+    hGetAll: jest.Mock<Promise<Record<string, string>>>;
+    hDel: jest.Mock<Promise<number>>;
+    hExists: jest.Mock<Promise<number>>;
+    expire: jest.Mock<Promise<number>>;
+    ttl: jest.Mock<Promise<number>>;
+    publish: jest.Mock<Promise<number>>;
+    [key: string]: unknown;
+}
+export interface RedisTestHelperOptions {
+    autoConnect?: boolean;
+    isOpen?: boolean;
+}
+export declare function createMockRedisClient(options?: RedisTestHelperOptions): MockRedisClient;
+export declare function resetMockRedisClient(client: MockRedisClient): void;
+export declare function setupRedisTestHelper(): {
+    mockClient: MockRedisClient;
+    reset: () => void;
+};
+export declare class RedisTestHelper {
+    private client;
+    constructor(options?: RedisTestHelperOptions);
+    getClient(): MockRedisClient;
+    reset(): void;
+    mockGet(key: string, value: string | null): void;
+    mockSet(_key: string, _value: string): void;
+    mockExists(key: string, exists: boolean): void;
+    mockKeys(_pattern: string, keys: string[]): void;
+    mockConnectError(error: Error): void;
+    mockQuitError(error: Error): void;
+    setConnectionState(isOpen: boolean): void;
+}

package/dist/cjs/__tests__/test-helpers/redis-test-helper.example.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/__tests__/test-helpers/redis-test-helper.example.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_test_helper_1 = require("./redis-test-helper");
+describe('RedisTestHelper Usage Examples', () => {
+    describe('using createMockRedisClient', () => {
+        it('should create a mock Redis client', async () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)();
+            expect(mockClient.isOpen).toBe(true);
+            expect(mockClient.connect).toBeDefined();
+            expect(mockClient.quit).toBeDefined();
+            await mockClient.connect();
+            expect(mockClient.connect).toHaveBeenCalledTimes(1);
+        });
+        it('should create a disconnected client', () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)({ isOpen: false });
+            expect(mockClient.isOpen).toBe(false);
+        });
+        it('should mock Redis operations', async () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)();
+            mockClient.get.mockResolvedValue('test-value');
+            mockClient.set.mockResolvedValue('OK');
+            const value = await mockClient.get('test-key');
+            expect(value).toBe('test-value');
+            const result = await mockClient.set('test-key', 'test-value');
+            expect(result).toBe('OK');
+        });
+    });
+    describe('using setupRedisTestHelper', () => {
+        it('should provide reset functionality', () => {
+            const { mockClient, reset } = (0, redis_test_helper_1.setupRedisTestHelper)();
+            mockClient.get('key1');
+            expect(mockClient.get).toHaveBeenCalledTimes(1);
+            reset();
+            expect(mockClient.get).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('using RedisTestHelper class', () => {
+        let helper;
+        beforeEach(() => {
+            helper = new redis_test_helper_1.RedisTestHelper();
+        });
+        afterEach(() => {
+            helper.reset();
+        });
+        it('should provide convenient mock methods', async () => {
+            const client = helper.getClient();
+            helper.mockGet('user:123', 'John Doe');
+            const value = await client.get('user:123');
+            expect(value).toBe('John Doe');
+            helper.mockExists('user:123', true);
+            const exists = await client.exists('user:123');
+            expect(exists).toBe(1);
+        });
+        it('should handle connection errors', async () => {
+            const error = new Error('Connection failed');
+            helper.mockConnectError(error);
+            const client = helper.getClient();
+            await expect(client.connect()).rejects.toThrow('Connection failed');
+        });
+        it('should allow changing connection state', () => {
+            const client = helper.getClient();
+            expect(client.isOpen).toBe(true);
+            helper.setConnectionState(false);
+            expect(client.isOpen).toBe(false);
+        });
+        it('should mock keys operation', async () => {
+            helper.mockKeys('user:*', ['user:1', 'user:2', 'user:3']);
+            const client = helper.getClient();
+            const keys = await client.keys('user:*');
+            expect(keys).toEqual(['user:1', 'user:2', 'user:3']);
+        });
+    });
+    describe('integration with RedisClientType', () => {
+        it('should have required Redis client methods', () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)();
+            expect(mockClient.connect).toBeDefined();
+            expect(mockClient.quit).toBeDefined();
+            expect(mockClient.isOpen).toBeDefined();
+            expect(typeof mockClient.connect).toBe('function');
+            expect(typeof mockClient.quit).toBe('function');
+        });
+    });
+});

package/dist/cjs/__tests__/test-helpers/redis-test-helper.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisTestHelper = void 0;
+exports.createMockRedisClient = createMockRedisClient;
+exports.resetMockRedisClient = resetMockRedisClient;
+exports.setupRedisTestHelper = setupRedisTestHelper;
+function createMockRedisClient(options = {}) {
+    const { autoConnect = true, isOpen = true } = options;
+    const mockClient = {
+        connect: jest.fn().mockResolvedValue(undefined),
+        quit: jest.fn().mockResolvedValue(undefined),
+        disconnect: jest.fn().mockResolvedValue(undefined),
+        isOpen,
+        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),
+    };
+    if (autoConnect) {
+        mockClient.connect.mockResolvedValue(undefined);
+    }
+    return mockClient;
+}
+function resetMockRedisClient(client) {
+    Object.keys(client).forEach((key) => {
+        if (jest.isMockFunction(client[key])) {
+            client[key].mockClear();
+        }
+    });
+}
+function setupRedisTestHelper() {
+    const mockClient = createMockRedisClient();
+    return {
+        mockClient,
+        reset: () => resetMockRedisClient(mockClient),
+    };
+}
+class RedisTestHelper {
+    constructor(options = {}) {
+        this.client = createMockRedisClient(options);
+    }
+    getClient() {
+        return this.client;
+    }
+    reset() {
+        resetMockRedisClient(this.client);
+    }
+    mockGet(key, value) {
+        this.client.get.mockImplementation((k) => {
+            if (k === key) {
+                return Promise.resolve(value);
+            }
+            return Promise.resolve(null);
+        });
+    }
+    mockSet(_key, _value) {
+        this.client.set.mockResolvedValue('OK');
+    }
+    mockExists(key, exists) {
+        this.client.exists.mockImplementation((k) => {
+            if (k === key) {
+                return Promise.resolve(exists ? 1 : 0);
+            }
+            return Promise.resolve(0);
+        });
+    }
+    mockKeys(_pattern, keys) {
+        this.client.keys.mockResolvedValue(keys);
+    }
+    mockConnectError(error) {
+        this.client.connect.mockRejectedValue(error);
+    }
+    mockQuitError(error) {
+        this.client.quit.mockRejectedValue(error);
+    }
+    setConnectionState(isOpen) {
+        Object.defineProperty(this.client, 'isOpen', {
+            value: isOpen,
+            writable: true,
+            configurable: true,
+        });
+    }
+}
+exports.RedisTestHelper = RedisTestHelper;

package/dist/cjs/cloud/new-deployment/build.js

@@ -8,6 +8,7 @@ const core_1 = require("@motiadev/core");
 const printer_1 = require("@motiadev/core/dist/src/printer");
 const fs_1 = __importDefault(require("fs"));
 const generate_locked_data_1 = require("../../generate-locked-data");
+const redis_memory_manager_1 = require("../../redis-memory-manager");
 const build_error_1 = require("../../utils/errors/build.error");
 const builder_1 = require("../build/builder");
 const node_1 = require("../build/builders/node");
@@ -26,7 +27,8 @@ const build = async (listener) => {
     builder.registerBuilder('node', new node_1.NodeBuilder(builder, listener));
     fs_1.default.rmSync(constants_1.distDir, { recursive: true, force: true });
     fs_1.default.mkdirSync(constants_1.distDir, { recursive: true });
-    const lockedData = new core_1.LockedData(constants_1.projectDir, new core_1.MemoryStreamAdapterManager(), new printer_1.NoPrinter());
+    const redisClient = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(constants_1.projectDir, false);
+    const lockedData = new core_1.LockedData(constants_1.projectDir, new core_1.MemoryStreamAdapterManager(), new printer_1.NoPrinter(), redisClient);
     if (hasPythonSteps(stepFiles)) {
         builder.registerBuilder('python', new python_1.PythonBuilder(builder, listener));
     }

package/dist/cjs/dev.js

@@ -1,18 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dev = void 0;
 const analytics_node_1 = require("@amplitude/analytics-node");
+const adapter_redis_state_1 = require("@motiadev/adapter-redis-state");
+const adapter_redis_streams_1 = require("@motiadev/adapter-redis-streams");
 const core_1 = require("@motiadev/core");
-const path_1 = __importDefault(require("path"));
 const endpoints_1 = require("./cloud/endpoints");
 const constants_1 = require("./constants");
 const dev_watchers_1 = require("./dev-watchers");
 const generate_locked_data_1 = require("./generate-locked-data");
 const load_motia_config_1 = require("./load-motia-config");
 const plugins_1 = require("./plugins");
+const redis_memory_manager_1 = require("./redis-memory-manager");
 const activate_python_env_1 = require("./utils/activate-python-env");
 const analytics_1 = require("./utils/analytics");
 const version_1 = require("./version");
@@ -41,20 +40,18 @@ const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFileStora
     }
     const motiaFileStoragePath = motiaFileStorageDir || '.motia';
     const appConfig = await (0, load_motia_config_1.loadMotiaConfig)(baseDir);
+    const redisClient = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(motiaFileStoragePath, true);
     const adapters = {
         eventAdapter: appConfig.adapters?.events || new core_1.DefaultQueueEventAdapter(),
         cronAdapter: appConfig.adapters?.cron || new core_1.DefaultCronAdapter(),
-        streamAdapter: appConfig.adapters?.streams || new core_1.FileStreamAdapterManager(baseDir, motiaFileStoragePath),
+        streamAdapter: appConfig.adapters?.streams || new adapter_redis_streams_1.RedisStreamAdapterManager(redisClient),
     };
     const lockedData = await (0, generate_locked_data_1.generateLockedData)({
         projectDir: baseDir,
         streamAdapter: adapters.streamAdapter,
+        redisClient,
     });
-    const state = appConfig.adapters?.state ||
-        (0, core_1.createStateAdapter)({
-            adapter: 'default',
-            filePath: path_1.default.join(baseDir, motiaFileStoragePath),
-        });
+    const state = appConfig.adapters?.state || new adapter_redis_state_1.RedisStateAdapter(redisClient);
     const config = { isVerbose };
     const motiaServer = (0, core_1.createServer)(lockedData, state, config, adapters, appConfig.app);
     const watcher = (0, dev_watchers_1.createDevWatchers)(lockedData, motiaServer, motiaServer.motiaEventManager, motiaServer.cronManager);
@@ -101,11 +98,11 @@ const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFileStora
     motiaServer.server.listen(port, hostname);
     console.log('🚀 Server ready and listening on port', port);
     console.log(`🔗 Open http://localhost:${port}${constants_1.workbenchBase} to open workbench 🛠️`);
-    // 6) Gracefully shut down on SIGTERM
     process.on('SIGTERM', async () => {
         (0, core_1.trackEvent)('dev_server_shutdown', { reason: 'SIGTERM' });
         motiaServer.server.close();
         await watcher.stop();
+        await (0, redis_memory_manager_1.stopRedisMemoryServer)();
         await (0, analytics_node_1.flush)().promise;
         process.exit(0);
     });
@@ -113,6 +110,7 @@ const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFileStora
         (0, core_1.trackEvent)('dev_server_shutdown', { reason: 'SIGINT' });
         motiaServer.server.close();
         await watcher.stop();
+        await (0, redis_memory_manager_1.stopRedisMemoryServer)();
         await (0, analytics_node_1.flush)().promise;
         process.exit(0);
     });

package/dist/cjs/generate-locked-data.d.ts

@@ -1,9 +1,11 @@
 import { LockedData, type Step, type StreamAdapterManager } from '@motiadev/core';
+import type { RedisClientType } from 'redis';
 export declare const getStepFiles: (projectDir: string) => string[];
 export declare const getStreamFiles: (projectDir: string) => string[];
 export declare const collectFlows: (projectDir: string, lockedData: LockedData) => Promise<Step[]>;
 export declare const generateLockedData: (config: {
     projectDir: string;
     streamAdapter: StreamAdapterManager;
+    redisClient: RedisClientType;
     printerType?: "disabled" | "default";
 }) => Promise<LockedData>;

package/dist/cjs/generate-locked-data.js

@@ -108,13 +108,13 @@ const collectFlows = async (projectDir, lockedData) => {
 exports.collectFlows = collectFlows;
 const generateLockedData = async (config) => {
     try {
-        const { projectDir, streamAdapter, printerType = 'default' } = config;
+        const { projectDir, streamAdapter, printerType = 'default', redisClient } = config;
         const printer = printerType === 'disabled' ? new printer_1.NoPrinter() : new printer_1.Printer(projectDir);
         /*
          * NOTE: right now for performance and simplicity let's enforce a folder,
          * but we might want to remove this and scan the entire current directory
          */
-        const lockedData = new core_1.LockedData(projectDir, streamAdapter, printer);
+        const lockedData = new core_1.LockedData(projectDir, streamAdapter, printer, redisClient);
         await (0, exports.collectFlows)(projectDir, lockedData);
         lockedData.saveTypes();
         return lockedData;

package/dist/cjs/generate-types.js

@@ -4,11 +4,13 @@ exports.generateTypes = void 0;
 const core_1 = require("@motiadev/core");
 const crypto_1 = require("crypto");
 const generate_locked_data_1 = require("./generate-locked-data");
+const redis_memory_manager_1 = require("./redis-memory-manager");
 const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
 const generateTypes = async (projectDir) => {
     const files = (0, generate_locked_data_1.getStepFiles)(projectDir);
     const streamsFiles = (0, generate_locked_data_1.getStreamFiles)(projectDir);
-    const lockedData = new core_1.LockedData(projectDir, new core_1.MemoryStreamAdapterManager(), new core_1.Printer(projectDir));
+    const redisClient = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(projectDir, false);
+    const lockedData = new core_1.LockedData(projectDir, new core_1.MemoryStreamAdapterManager(), new core_1.Printer(projectDir), redisClient);
     for (const filePath of files) {
         const config = await (0, core_1.getStepConfig)(filePath, projectDir);
         if (config) {

package/dist/cjs/redis-memory-manager.d.ts

@@ -0,0 +1,7 @@
+import { type RedisClientType } from 'redis';
+export interface RedisConnectionInfo {
+    host: string;
+    port: number;
+}
+export declare const instanceRedisMemoryServer: (baseDir: string, autoStart?: boolean) => Promise<RedisClientType>;
+export declare const stopRedisMemoryServer: () => Promise<void>;