motia 0.14.0-beta.165-285707 → 0.15.0-beta.165

package/dist/esm/__tests__/openapi/generate.test.js

@@ -1,252 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { generateOpenApi } from '../../openapi/generate';
-jest.mock('fs', () => ({
-    readFileSync: jest.fn(),
-    writeFileSync: jest.fn(),
-}));
-describe('generateOpenApi', () => {
-    const mockProjectDir = '/mock/project';
-    const mockOutputFile = 'mock-project-openapi.json';
-    beforeEach(() => {
-        jest.clearAllMocks();
-        fs.readFileSync.mockReturnValue(JSON.stringify({ name: 'test-project', version: '1.0.0' }));
-    });
-    const MOCK_API_STEP = {
-        filePath: '/mock/project/steps/test.ts',
-        version: '1.0.0',
-        config: {
-            type: 'api',
-            name: 'testApi',
-            path: '/test',
-            method: 'GET',
-            emits: [],
-        },
-    };
-    it('should generate a basic OpenAPI spec with default info', () => {
-        const apiSteps = [MOCK_API_STEP];
-        generateOpenApi(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
-        const expectedOpenApi = {
-            openapi: '3.0.0',
-            info: {
-                title: 'test-project',
-                version: '1.0.0',
-            },
-            paths: {
-                '/test': {
-                    get: {
-                        summary: 'testApi',
-                        description: undefined,
-                        requestBody: undefined,
-                        responses: {},
-                    },
-                },
-            },
-            components: {
-                schemas: {},
-            },
-        };
-        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
-    });
-    it('should handle bodySchema and responseSchema correctly', () => {
-        const mockBodySchema = {
-            type: 'object',
-            properties: {
-                id: { type: 'string' },
-            },
-        };
-        const mockResponseSchema = {
-            200: {
-                type: 'object',
-                properties: {
-                    message: { type: 'string' },
-                },
-            },
-        };
-        const mockApiStep = {
-            ...MOCK_API_STEP,
-            config: {
-                ...MOCK_API_STEP.config,
-                type: 'api',
-                name: 'testApiWithSchemas',
-                path: '/test-schemas',
-                method: 'POST',
-                bodySchema: mockBodySchema,
-                responseSchema: mockResponseSchema,
-                emits: [],
-            },
-        };
-        const apiSteps = [mockApiStep];
-        generateOpenApi(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
-        const expectedOpenApi = {
-            openapi: '3.0.0',
-            info: {
-                title: 'test-project',
-                version: '1.0.0',
-            },
-            paths: {
-                '/test-schemas': {
-                    post: {
-                        summary: 'testApiWithSchemas',
-                        description: undefined,
-                        requestBody: {
-                            content: {
-                                'application/json': {
-                                    schema: mockBodySchema,
-                                },
-                            },
-                        },
-                        responses: {
-                            200: {
-                                description: 'Response for status code 200',
-                                content: {
-                                    'application/json': {
-                                        schema: mockResponseSchema[200],
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            components: {
-                schemas: {},
-            },
-        };
-        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
-    });
-    it('should use provided title', () => {
-        const apiSteps = [MOCK_API_STEP];
-        const customTitle = 'Custom API';
-        generateOpenApi(mockProjectDir, apiSteps, customTitle);
-        const expectedOpenApi = {
-            openapi: '3.0.0',
-            info: {
-                title: customTitle,
-                version: '1.0.0',
-            },
-            paths: {
-                '/test': {
-                    get: {
-                        summary: 'testApi',
-                        description: undefined,
-                        requestBody: undefined,
-                        responses: {},
-                    },
-                },
-            },
-            components: {
-                schemas: {},
-            },
-        };
-        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, 'openapi.json'), JSON.stringify(expectedOpenApi, null, 2));
-    });
-    it('should use provided version', () => {
-        const apiSteps = [MOCK_API_STEP];
-        const customVersion = '2.0.0';
-        generateOpenApi(mockProjectDir, apiSteps, undefined, customVersion, mockOutputFile);
-        const expectedOpenApi = {
-            openapi: '3.0.0',
-            info: {
-                title: 'test-project',
-                version: customVersion,
-            },
-            paths: {
-                '/test': {
-                    get: {
-                        summary: 'testApi',
-                        description: undefined,
-                        requestBody: undefined,
-                        responses: {},
-                    },
-                },
-            },
-            components: {
-                schemas: {},
-            },
-        };
-        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
-    });
-    it('should handle complex bodySchema with anyOf, nullable, and $ref', () => {
-        const mockUserSchema = {
-            type: 'object',
-            properties: {
-                name: { type: 'string' },
-                email: { type: 'string', format: 'email' },
-            },
-            required: ['name', 'email'],
-        };
-        const mockComplexBodySchema = {
-            type: 'object',
-            properties: {
-                id: { type: 'string' },
-                status: {
-                    anyOf: [{ type: 'string', enum: ['active', 'inactive'] }, { type: 'number', enum: [0, 1] }, { type: 'null' }],
-                },
-                user: { $ref: '#/components/schemas/User' },
-            },
-            required: ['id'],
-            $defs: {
-                User: mockUserSchema,
-            },
-        };
-        const mockApiStep = {
-            ...MOCK_API_STEP,
-            filePath: '/mock/project/steps/complex.ts',
-            config: {
-                ...MOCK_API_STEP.config,
-                type: 'api',
-                name: 'testComplexApi',
-                path: '/test-complex',
-                method: 'PUT',
-                emits: [],
-                bodySchema: mockComplexBodySchema,
-            },
-        };
-        const apiSteps = [mockApiStep];
-        generateOpenApi(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
-        const expectedOpenApi = {
-            openapi: '3.0.0',
-            info: {
-                title: 'test-project',
-                version: '1.0.0',
-            },
-            paths: {
-                '/test-complex': {
-                    put: {
-                        summary: 'testComplexApi',
-                        description: undefined,
-                        requestBody: {
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        properties: {
-                                            id: { type: 'string' },
-                                            status: {
-                                                anyOf: [
-                                                    { type: 'string', enum: ['active', 'inactive'] },
-                                                    { type: 'number', enum: [0, 1] },
-                                                ],
-                                                nullable: true,
-                                            },
-                                            user: { $ref: '#/components/schemas/User' },
-                                        },
-                                        required: ['id'],
-                                    },
-                                },
-                            },
-                        },
-                        responses: {},
-                    },
-                },
-            },
-            components: {
-                schemas: {
-                    User: mockUserSchema,
-                },
-            },
-        };
-        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
-    });
-});

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=redis-memory-manager.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"redis-memory-manager.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/redis-memory-manager.test.ts"],"names":[],"mappings":""}

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

@@ -1,174 +0,0 @@
-import { mkdirSync } from 'fs';
-import { createClient } from 'redis';
-import { RedisMemoryServer } from 'redis-memory-server';
-import { instanceRedisMemoryServer, stopRedisMemoryServer } from '../redis-memory-manager';
-jest.mock('fs');
-jest.mock('redis');
-jest.mock('redis-memory-server');
-const mockMkdirSync = mkdirSync;
-const mockCreateClient = createClient;
-const mockRedisMemoryServer = 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 stopRedisMemoryServer();
-        process.env = originalEnv;
-    });
-    describe('instanceRedisMemoryServer', () => {
-        it('should start Redis server and return client', async () => {
-            const baseDir = '/test/dir';
-            const client = await 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,
-                    keepAlive: true,
-                    noDelay: true,
-                },
-            });
-            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 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 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 instanceRedisMemoryServer(baseDir, true);
-            const client2 = await 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 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(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(instanceRedisMemoryServer(baseDir, true)).rejects.toThrow('Server start failed');
-        });
-        it('should implement reconnect strategy correctly', async () => {
-            const baseDir = '/test/dir';
-            await 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');
-            const mockError = new Error('test');
-            const strategyFn = reconnectStrategy;
-            expect(strategyFn(5, mockError)).toBe(500);
-            expect(strategyFn(10, mockError)).toBe(1000);
-            expect(strategyFn(11, mockError)).toBeInstanceOf(Error);
-            expect(strategyFn(11, mockError).message).toBe('Redis connection retry limit exceeded');
-            expect(strategyFn(15, mockError)).toBeInstanceOf(Error);
-            expect(strategyFn(20, mockError)).toBeInstanceOf(Error);
-            expect(strategyFn(30, mockError)).toBeInstanceOf(Error);
-            expect(strategyFn(50, mockError)).toBeInstanceOf(Error);
-        });
-    });
-    describe('stopRedisMemoryServer', () => {
-        it('should stop Redis server and close client', async () => {
-            const baseDir = '/test/dir';
-            await instanceRedisMemoryServer(baseDir, true);
-            await stopRedisMemoryServer();
-            expect(mockRedisClient.quit).toHaveBeenCalled();
-            expect(mockServerInstance.stop).toHaveBeenCalled();
-        });
-        it('should handle client close errors gracefully', async () => {
-            const baseDir = '/test/dir';
-            await instanceRedisMemoryServer(baseDir, true);
-            const error = new Error('Close failed');
-            mockRedisClient.quit.mockRejectedValue(error);
-            await stopRedisMemoryServer();
-            expect(mockRedisClient.quit).toHaveBeenCalled();
-            expect(mockServerInstance.stop).toHaveBeenCalled();
-        });
-        it('should handle server stop errors gracefully', async () => {
-            const baseDir = '/test/dir';
-            await instanceRedisMemoryServer(baseDir, true);
-            const error = new Error('Stop failed');
-            mockServerInstance.stop.mockRejectedValue(error);
-            await stopRedisMemoryServer();
-            expect(mockRedisClient.quit).toHaveBeenCalled();
-            expect(mockServerInstance.stop).toHaveBeenCalled();
-        });
-        it('should not throw if client is not open', async () => {
-            const baseDir = '/test/dir';
-            await instanceRedisMemoryServer(baseDir, true);
-            Object.defineProperty(mockRedisClient, 'isOpen', {
-                value: false,
-                writable: true,
-                configurable: true,
-            });
-            await expect(stopRedisMemoryServer()).resolves.not.toThrow();
-        });
-        it('should do nothing if server is not running', async () => {
-            await stopRedisMemoryServer();
-            expect(mockRedisClient.quit).not.toHaveBeenCalled();
-            expect(mockServerInstance.stop).not.toHaveBeenCalled();
-        });
-    });
-});

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

@@ -1,52 +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;
-}
-//# sourceMappingURL=redis-test-helper.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"redis-test-helper.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/test-helpers/redis-test-helper.ts"],"names":[],"mappings":"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"}

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=redis-test-helper.example.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"redis-test-helper.example.test.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/test-helpers/redis-test-helper.example.test.ts"],"names":[],"mappings":""}

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

@@ -1,81 +0,0 @@
-import { createMockRedisClient, RedisTestHelper, setupRedisTestHelper } from './redis-test-helper';
-describe('RedisTestHelper Usage Examples', () => {
-    describe('using createMockRedisClient', () => {
-        it('should create a mock Redis client', async () => {
-            const mockClient = 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 = createMockRedisClient({ isOpen: false });
-            expect(mockClient.isOpen).toBe(false);
-        });
-        it('should mock Redis operations', async () => {
-            const mockClient = 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 } = setupRedisTestHelper();
-            mockClient.get('key1');
-            expect(mockClient.get).toHaveBeenCalledTimes(1);
-            reset();
-            expect(mockClient.get).toHaveBeenCalledTimes(0);
-        });
-    });
-    describe('using RedisTestHelper class', () => {
-        let helper;
-        beforeEach(() => {
-            helper = new 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 = 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/esm/__tests__/test-helpers/redis-test-helper.js

@@ -1,94 +0,0 @@
-export 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;
-}
-export function resetMockRedisClient(client) {
-    Object.keys(client).forEach((key) => {
-        if (jest.isMockFunction(client[key])) {
-            client[key].mockClear();
-        }
-    });
-}
-export function setupRedisTestHelper() {
-    const mockClient = createMockRedisClient();
-    return {
-        mockClient,
-        reset: () => resetMockRedisClient(mockClient),
-    };
-}
-export 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,
-        });
-    }
-}

package/dist/esm/cli.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import './cloud';
-//# sourceMappingURL=cli.d.ts.map