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

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

@@ -8,7 +8,6 @@ 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");
@@ -27,8 +26,7 @@ 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 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);
+    const lockedData = new core_1.LockedData(constants_1.projectDir, new core_1.MemoryStreamAdapterManager(), new printer_1.NoPrinter());
     if (hasPythonSteps(stepFiles)) {
         builder.registerBuilder('python', new python_1.PythonBuilder(builder, listener));
     }

package/dist/cjs/dev.js

@@ -1,17 +1,18 @@
 "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");
@@ -40,18 +41,20 @@ 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 adapter_redis_streams_1.RedisStreamAdapterManager(redisClient),
+        streamAdapter: appConfig.adapters?.streams || new core_1.FileStreamAdapterManager(baseDir, motiaFileStoragePath),
     };
     const lockedData = await (0, generate_locked_data_1.generateLockedData)({
         projectDir: baseDir,
         streamAdapter: adapters.streamAdapter,
-        redisClient,
     });
-    const state = appConfig.adapters?.state || new adapter_redis_state_1.RedisStateAdapter(redisClient);
+    const state = appConfig.adapters?.state ||
+        (0, core_1.createStateAdapter)({
+            adapter: 'default',
+            filePath: path_1.default.join(baseDir, motiaFileStoragePath),
+        });
     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);
@@ -98,11 +101,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);
     });
@@ -110,7 +113,6 @@ 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,11 +1,9 @@
 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', redisClient } = config;
+        const { projectDir, streamAdapter, printerType = 'default' } = 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, redisClient);
+        const lockedData = new core_1.LockedData(projectDir, streamAdapter, printer);
         await (0, exports.collectFlows)(projectDir, lockedData);
         lockedData.saveTypes();
         return lockedData;

package/dist/cjs/generate-types.js

@@ -4,13 +4,11 @@ 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 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);
+    const lockedData = new core_1.LockedData(projectDir, new core_1.MemoryStreamAdapterManager(), new core_1.Printer(projectDir));
     for (const filePath of files) {
         const config = await (0, core_1.getStepConfig)(filePath, projectDir);
         if (config) {

package/dist/cjs/start.js

@@ -4,15 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.start = void 0;
-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 constants_1 = require("./constants");
 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 version_1 = require("./version");
 require('ts-node').register({
@@ -31,18 +28,16 @@ const start = async (port, hostname, disableVerbose, motiaFileStorageDir) => {
     const motiaFileStoragePath = motiaFileStorageDir || '.motia';
     const dotMotia = path_1.default.join(baseDir, motiaFileStoragePath);
     const appConfig = await (0, load_motia_config_1.loadMotiaConfig)(baseDir);
-    const redisClient = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(dotMotia);
     const adapters = {
         eventAdapter: appConfig.adapters?.events || new core_1.DefaultQueueEventAdapter(),
         cronAdapter: appConfig.adapters?.cron || new core_1.DefaultCronAdapter(),
-        streamAdapter: appConfig.adapters?.streams || new adapter_redis_streams_1.RedisStreamAdapterManager(redisClient),
+        streamAdapter: appConfig.adapters?.streams || new core_1.FileStreamAdapterManager(baseDir),
     };
     const lockedData = await (0, generate_locked_data_1.generateLockedData)({
         projectDir: baseDir,
         streamAdapter: adapters.streamAdapter,
-        redisClient,
     });
-    const state = appConfig.adapters?.state || new adapter_redis_state_1.RedisStateAdapter(redisClient);
+    const state = appConfig.adapters?.state || (0, core_1.createStateAdapter)({ adapter: 'default', filePath: dotMotia });
     const config = { isVerbose, isDev: false, version: version_1.version };
     const motiaServer = (0, core_1.createServer)(lockedData, state, config, adapters, appConfig.app);
     const plugins = await (0, plugins_1.processPlugins)(motiaServer);
@@ -58,14 +53,13 @@ const start = async (port, hostname, disableVerbose, motiaFileStorageDir) => {
     motiaServer.server.listen(port, hostname);
     console.log('🚀 Server ready and listening on port', port);
     console.log(`🔗 Open http://${hostname}:${port}${constants_1.workbenchBase} to open workbench 🛠️`);
+    // 6) Gracefully shut down on SIGTERM
     process.on('SIGTERM', async () => {
         motiaServer.server.close();
-        await (0, redis_memory_manager_1.stopRedisMemoryServer)();
         process.exit(0);
     });
     process.on('SIGINT', async () => {
         motiaServer.server.close();
-        await (0, redis_memory_manager_1.stopRedisMemoryServer)();
         process.exit(0);
     });
 };

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

@@ -2,7 +2,6 @@ import { isApiStep, LockedData, MemoryStreamAdapterManager } from '@motiadev/cor
 import { NoPrinter } from '@motiadev/core/dist/src/printer';
 import fs from 'fs';
 import { collectFlows, getStepFiles } from '../../generate-locked-data';
-import { instanceRedisMemoryServer } from '../../redis-memory-manager';
 import { BuildError, BuildErrorType } from '../../utils/errors/build.error';
 import { Builder } from '../build/builder';
 import { NodeBuilder } from '../build/builders/node';
@@ -21,8 +20,7 @@ export const build = async (listener) => {
     builder.registerBuilder('node', new NodeBuilder(builder, listener));
     fs.rmSync(distDir, { recursive: true, force: true });
     fs.mkdirSync(distDir, { recursive: true });
-    const redisClient = await instanceRedisMemoryServer(projectDir, false);
-    const lockedData = new LockedData(projectDir, new MemoryStreamAdapterManager(), new NoPrinter(), redisClient);
+    const lockedData = new LockedData(projectDir, new MemoryStreamAdapterManager(), new NoPrinter());
     if (hasPythonSteps(stepFiles)) {
         builder.registerBuilder('python', new PythonBuilder(builder, listener));
     }

package/dist/esm/dev.js

@@ -1,14 +1,12 @@
 import { flush } from '@amplitude/analytics-node';
-import { RedisStateAdapter } from '@motiadev/adapter-redis-state';
-import { RedisStreamAdapterManager } from '@motiadev/adapter-redis-streams';
-import { createMermaidGenerator, createServer, DefaultCronAdapter, DefaultQueueEventAdapter, getProjectIdentifier, trackEvent, } from '@motiadev/core';
+import { createMermaidGenerator, createServer, createStateAdapter, DefaultCronAdapter, DefaultQueueEventAdapter, FileStreamAdapterManager, getProjectIdentifier, trackEvent, } from '@motiadev/core';
+import path from 'path';
 import { deployEndpoints } from './cloud/endpoints';
 import { isTutorialDisabled, workbenchBase } from './constants';
 import { createDevWatchers } from './dev-watchers';
 import { generateLockedData, getStepFiles } from './generate-locked-data';
 import { loadMotiaConfig } from './load-motia-config';
 import { processPlugins } from './plugins';
-import { instanceRedisMemoryServer, stopRedisMemoryServer } from './redis-memory-manager';
 import { activatePythonVenv } from './utils/activate-python-env';
 import { identifyUser } from './utils/analytics';
 import { version } from './version';
@@ -37,18 +35,20 @@ export const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFi
     }
     const motiaFileStoragePath = motiaFileStorageDir || '.motia';
     const appConfig = await loadMotiaConfig(baseDir);
-    const redisClient = await instanceRedisMemoryServer(motiaFileStoragePath, true);
     const adapters = {
         eventAdapter: appConfig.adapters?.events || new DefaultQueueEventAdapter(),
         cronAdapter: appConfig.adapters?.cron || new DefaultCronAdapter(),
-        streamAdapter: appConfig.adapters?.streams || new RedisStreamAdapterManager(redisClient),
+        streamAdapter: appConfig.adapters?.streams || new FileStreamAdapterManager(baseDir, motiaFileStoragePath),
     };
     const lockedData = await generateLockedData({
         projectDir: baseDir,
         streamAdapter: adapters.streamAdapter,
-        redisClient,
     });
-    const state = appConfig.adapters?.state || new RedisStateAdapter(redisClient);
+    const state = appConfig.adapters?.state ||
+        createStateAdapter({
+            adapter: 'default',
+            filePath: path.join(baseDir, motiaFileStoragePath),
+        });
     const config = { isVerbose };
     const motiaServer = createServer(lockedData, state, config, adapters, appConfig.app);
     const watcher = createDevWatchers(lockedData, motiaServer, motiaServer.motiaEventManager, motiaServer.cronManager);
@@ -95,11 +95,11 @@ export const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFi
     motiaServer.server.listen(port, hostname);
     console.log('🚀 Server ready and listening on port', port);
     console.log(`🔗 Open http://localhost:${port}${workbenchBase} to open workbench 🛠️`);
+    // 6) Gracefully shut down on SIGTERM
     process.on('SIGTERM', async () => {
         trackEvent('dev_server_shutdown', { reason: 'SIGTERM' });
         motiaServer.server.close();
         await watcher.stop();
-        await stopRedisMemoryServer();
         await flush().promise;
         process.exit(0);
     });
@@ -107,7 +107,6 @@ export const dev = async (port, hostname, disableVerbose, enableMermaid, motiaFi
         trackEvent('dev_server_shutdown', { reason: 'SIGINT' });
         motiaServer.server.close();
         await watcher.stop();
-        await stopRedisMemoryServer();
         await flush().promise;
         process.exit(0);
     });

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

@@ -1,11 +1,9 @@
 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/esm/generate-locked-data.js

@@ -99,13 +99,13 @@ export const collectFlows = async (projectDir, lockedData) => {
 };
 export const generateLockedData = async (config) => {
     try {
-        const { projectDir, streamAdapter, printerType = 'default', redisClient } = config;
+        const { projectDir, streamAdapter, printerType = 'default' } = config;
         const printer = printerType === 'disabled' ? new NoPrinter() : new 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 LockedData(projectDir, streamAdapter, printer, redisClient);
+        const lockedData = new LockedData(projectDir, streamAdapter, printer);
         await collectFlows(projectDir, lockedData);
         lockedData.saveTypes();
         return lockedData;

package/dist/esm/generate-types.js

@@ -1,13 +1,11 @@
 import { getStepConfig, getStreamConfig, LockedData, MemoryStreamAdapterManager, Printer } from '@motiadev/core';
 import { randomUUID } from 'crypto';
 import { getStepFiles, getStreamFiles } from './generate-locked-data';
-import { instanceRedisMemoryServer } from './redis-memory-manager';
 const version = `${randomUUID()}:${Math.floor(Date.now() / 1000)}`;
 export const generateTypes = async (projectDir) => {
     const files = getStepFiles(projectDir);
     const streamsFiles = getStreamFiles(projectDir);
-    const redisClient = await instanceRedisMemoryServer(projectDir, false);
-    const lockedData = new LockedData(projectDir, new MemoryStreamAdapterManager(), new Printer(projectDir), redisClient);
+    const lockedData = new LockedData(projectDir, new MemoryStreamAdapterManager(), new Printer(projectDir));
     for (const filePath of files) {
         const config = await getStepConfig(filePath, projectDir);
         if (config) {

package/dist/esm/start.js

@@ -1,12 +1,9 @@
-import { RedisStateAdapter } from '@motiadev/adapter-redis-state';
-import { RedisStreamAdapterManager } from '@motiadev/adapter-redis-streams';
-import { createServer, DefaultCronAdapter, DefaultQueueEventAdapter } from '@motiadev/core';
+import { createServer, createStateAdapter, DefaultCronAdapter, DefaultQueueEventAdapter, FileStreamAdapterManager, } from '@motiadev/core';
 import path from 'path';
 import { workbenchBase } from './constants';
 import { generateLockedData, getStepFiles } from './generate-locked-data';
 import { loadMotiaConfig } from './load-motia-config';
 import { processPlugins } from './plugins';
-import { instanceRedisMemoryServer, stopRedisMemoryServer } from './redis-memory-manager';
 import { activatePythonVenv } from './utils/activate-python-env';
 import { version } from './version';
 require('ts-node').register({
@@ -25,18 +22,16 @@ export const start = async (port, hostname, disableVerbose, motiaFileStorageDir)
     const motiaFileStoragePath = motiaFileStorageDir || '.motia';
     const dotMotia = path.join(baseDir, motiaFileStoragePath);
     const appConfig = await loadMotiaConfig(baseDir);
-    const redisClient = await instanceRedisMemoryServer(dotMotia);
     const adapters = {
         eventAdapter: appConfig.adapters?.events || new DefaultQueueEventAdapter(),
         cronAdapter: appConfig.adapters?.cron || new DefaultCronAdapter(),
-        streamAdapter: appConfig.adapters?.streams || new RedisStreamAdapterManager(redisClient),
+        streamAdapter: appConfig.adapters?.streams || new FileStreamAdapterManager(baseDir),
     };
     const lockedData = await generateLockedData({
         projectDir: baseDir,
         streamAdapter: adapters.streamAdapter,
-        redisClient,
     });
-    const state = appConfig.adapters?.state || new RedisStateAdapter(redisClient);
+    const state = appConfig.adapters?.state || createStateAdapter({ adapter: 'default', filePath: dotMotia });
     const config = { isVerbose, isDev: false, version };
     const motiaServer = createServer(lockedData, state, config, adapters, appConfig.app);
     const plugins = await processPlugins(motiaServer);
@@ -52,14 +47,13 @@ export const start = async (port, hostname, disableVerbose, motiaFileStorageDir)
     motiaServer.server.listen(port, hostname);
     console.log('🚀 Server ready and listening on port', port);
     console.log(`🔗 Open http://${hostname}:${port}${workbenchBase} to open workbench 🛠️`);
+    // 6) Gracefully shut down on SIGTERM
     process.on('SIGTERM', async () => {
         motiaServer.server.close();
-        await stopRedisMemoryServer();
         process.exit(0);
     });
     process.on('SIGINT', async () => {
         motiaServer.server.close();
-        await stopRedisMemoryServer();
         process.exit(0);
     });
 };

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

@@ -1,11 +1,9 @@
 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "motia",
   "description": "Build production-grade backends with a single primitive. APIs, background jobs, Queues, Workflows, and AI agents - unified in one system with built-in State management, Streaming, and Observability.",
-  "version": "0.11.1-beta.156-879726",
+  "version": "0.11.1-beta.156-960492",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -44,15 +44,11 @@
     "inquirer": "^8.2.5",
     "node-cron": "^3.0.3",
     "python-ast": "^0.1.0",
-    "redis": "^5.9.0",
-    "redis-memory-server": "^0.14.0",
     "table": "^6.9.0",
     "ts-node": "^10.9.2",
-    "@motiadev/adapter-redis-state": "0.11.1-beta.156-879726",
-    "@motiadev/core": "0.11.1-beta.156-879726",
-    "@motiadev/stream-client-node": "0.11.1-beta.156-879726",
-    "@motiadev/workbench": "0.11.1-beta.156-879726",
-    "@motiadev/adapter-redis-streams": "0.11.1-beta.156-879726"
+    "@motiadev/stream-client-node": "0.11.1-beta.156-960492",
+    "@motiadev/core": "0.11.1-beta.156-960492",
+    "@motiadev/workbench": "0.11.1-beta.156-960492"
   },
   "devDependencies": {
     "@amplitude/analytics-types": "^2.9.2",

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

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

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

@@ -1,175 +0,0 @@
-"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

@@ -1,51 +0,0 @@
-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

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