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

package/dist/cjs/__tests__/openapi/generate.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=generate.test.d.ts.map

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/cli.d.ts

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

package/dist/cjs/cli.js

@@ -1,11 +1,9 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@motiadev/core");
 const commander_1 = require("commander");
 require("./cloud");
 const config_utils_1 = require("./cloud/config-utils");
-const load_motia_config_1 = require("./load-motia-config");
 const analytics_1 = require("./utils/analytics");
 const version_1 = require("./version");
 const defaultPort = 3000;
@@ -144,16 +142,7 @@ generate
     .action((0, analytics_1.wrapAction)(async (options) => {
     const { generateLockedData } = require('./generate-locked-data');
     const { generateOpenApi } = require('./openapi/generate');
-    const baseDir = process.cwd();
-    const appConfig = await (0, load_motia_config_1.loadMotiaConfig)(baseDir);
-    const streamAuth = appConfig.streamAuth
-        ? { authenticate: appConfig.streamAuth.authenticate, contextSchema: appConfig.__streamAuthContextSchema }
-        : undefined;
-    const lockedData = await generateLockedData({
-        projectDir: baseDir,
-        streamAdapter: new core_1.MemoryStreamAdapterManager(),
-        streamAuth,
-    });
+    const lockedData = await generateLockedData({ projectDir: process.cwd() });
     const apiSteps = lockedData.apiSteps();
     generateOpenApi(process.cwd(), apiSteps, options.title, options.version, options.output);
     process.exit(0);

package/dist/cjs/cloud/build/__tests__/infrastructure-serialization.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=infrastructure-serialization.test.d.ts.map

package/dist/cjs/cloud/build/__tests__/infrastructure-validation.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=infrastructure-validation.test.d.ts.map

package/dist/cjs/cloud/build/build-validation.d.ts

@@ -3,4 +3,3 @@ import type { Builder } from './builder';
 import type { ValidationResult } from './validations/types';
 export declare const buildValidation: (builder: Builder, listener: BuildListener) => boolean;
 export declare const validateStepsConfig: (builder: Builder) => ValidationResult;
-//# sourceMappingURL=build-validation.d.ts.map

package/dist/cjs/cloud/build/builder.d.ts

@@ -55,4 +55,3 @@ export declare class Builder {
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<void>;
     private determineStepType;
 }
-//# sourceMappingURL=builder.d.ts.map

package/dist/cjs/cloud/build/builders/archiver.d.ts

@@ -13,4 +13,3 @@ export declare class Archiver {
     append(stream: fs.ReadStream | string | Buffer, filePath: string): void;
     finalize(): Promise<ArchiveResult>;
 }
-//# sourceMappingURL=archiver.d.ts.map

package/dist/cjs/cloud/build/builders/include-static-files.d.ts

@@ -2,4 +2,3 @@ import type { Step } from '@motiadev/core';
 import type { Builder } from '../builder';
 import type { Archiver } from './archiver';
 export declare const includeStaticFiles: (steps: Step[], builder: Builder, archive: Archiver) => void;
-//# sourceMappingURL=include-static-files.d.ts.map

package/dist/cjs/cloud/build/builders/node/index.d.ts

@@ -9,4 +9,3 @@ export declare class NodeBuilder implements StepBuilder {
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
     build(step: Step): Promise<void>;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/cjs/cloud/build/builders/node/router-template.d.ts

@@ -7,4 +7,3 @@ type RouterPath = {
 };
 export declare const routerPaths: Record<string, RouterPath>;
 export {};
-//# sourceMappingURL=router-template.d.ts.map

package/dist/cjs/cloud/build/builders/python/index.d.ts

@@ -13,4 +13,3 @@ export declare class PythonBuilder implements StepBuilder {
     private createRouterTemplate;
     private getModuleName;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/convert-import-path.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=convert-import-path.test.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/extract-python-data.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=extract-python-data.test.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/get-dependencies-from-file.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=get-dependencies-from-file.test.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/read-requirements.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=read-requirements.test.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/resolve-dep-name.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=resolve-dep-name.test.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/constants.d.ts

@@ -1,2 +1 @@
 export declare const STANDARD_LIB_MODULES: Set<string>;
-//# sourceMappingURL=constants.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/convert-import-path.d.ts

@@ -1,2 +1 @@
 export declare const convertImportToPath: (module: string) => string;
-//# sourceMappingURL=convert-import-path.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/extract-python-data.d.ts

@@ -5,4 +5,3 @@ export type PythonResult = {
     files: string[];
 };
 export declare const extractPythonData: (rootDir: string, filePath: string, dependenciesMap: Record<string, string>, fileContent?: string) => PythonResult;
-//# sourceMappingURL=extract-python-data.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/get-dependencies-from-file.d.ts

@@ -4,4 +4,3 @@ export type Dependencies = {
     projectDependencies: Set<string>;
 };
 export declare const getDependenciesFromFile: (content: string, path: string, externalDependenciesMap: Record<string, string>) => Dependencies;
-//# sourceMappingURL=get-dependencies-from-file.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/python-errors.d.ts

@@ -11,4 +11,3 @@ export declare class PythonImportNotFoundError extends PythonError {
 export declare class PythonCompilationError extends PythonError {
     constructor(filePath: string, errorMessage: string);
 }
-//# sourceMappingURL=python-errors.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/read-requirements.d.ts

@@ -11,4 +11,3 @@ export type Requirements = Record<string, string>;
  * @returns set of all dependencies names
  */
 export declare const readRequirements: (filePath: string) => Requirements;
-//# sourceMappingURL=read-requirements.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/resolve-dep-names.d.ts

@@ -4,4 +4,3 @@
  * @returns a map of the import name to the package name
  */
 export declare const resolveDepNames: (depNames: string[], sitePackagesDir: string) => Record<string, string>;
-//# sourceMappingURL=resolve-dep-names.d.ts.map

package/dist/cjs/cloud/build/builders/python/python-data/traverse-tree.d.ts

@@ -4,4 +4,3 @@ export type TraverseTreeResult = {
     files: Set<string>;
 };
 export declare const traverseTree: (rootDir: string, filePath: string, result: TraverseTreeResult, dependenciesMap: Record<string, string>, fileContent?: string) => void;
-//# sourceMappingURL=traverse-tree.d.ts.map

package/dist/cjs/cloud/build/builders/python/uv-packager.d.ts

@@ -10,4 +10,3 @@ export declare class UvPackager {
     packageDependencies(cwd: string): Promise<void>;
     private runCommand;
 }
-//# sourceMappingURL=uv-packager.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/api-endpoints.validator.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=api-endpoints.validator.test.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/build-validation.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=build-validation.test.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/cron-expressions.validator.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=cron-expressions.validator.test.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/duplicate-step-names.validator.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=duplicate-step-names.validator.test.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/router-bundle-sizes.validator.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=router-bundle-sizes.validator.test.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/step-bundle-sizes.validator.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=step-bundle-sizes.validator.test.d.ts.map

package/dist/cjs/cloud/build/validations/__tests__/step-name-lengths.validator.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=step-name-lengths.validator.test.d.ts.map

package/dist/cjs/cloud/build/validations/api-endpoints.validator.d.ts

@@ -1,3 +1,2 @@
 import type { Validator } from './types';
 export declare const apiEndpointsValidator: Validator;
-//# sourceMappingURL=api-endpoints.validator.d.ts.map

package/dist/cjs/cloud/build/validations/constants.d.ts

@@ -4,4 +4,3 @@ export declare const BUNDLE_SIZE_LIMITS: {
     STEP_NAME_MAX_LENGTH: number;
 };
 export declare const BYTES_TO_MB: number;
-//# sourceMappingURL=constants.d.ts.map

package/dist/cjs/cloud/build/validations/cron-expressions.validator.d.ts

@@ -1,3 +1,2 @@
 import type { Validator } from './types';
 export declare const cronExpressionsValidator: Validator;
-//# sourceMappingURL=cron-expressions.validator.d.ts.map

package/dist/cjs/cloud/build/validations/duplicate-step-names.validator.d.ts

@@ -1,3 +1,2 @@
 import type { Validator } from './types';
 export declare const duplicateStepNamesValidator: Validator;
-//# sourceMappingURL=duplicate-step-names.validator.d.ts.map

package/dist/cjs/cloud/build/validations/infrastructure-configs.validator.d.ts

@@ -1,3 +1,2 @@
 import type { Validator } from './types';
 export declare const infrastructureConfigsValidator: Validator;
-//# sourceMappingURL=infrastructure-configs.validator.d.ts.map

package/dist/cjs/cloud/build/validations/router-bundle-sizes.validator.d.ts

@@ -1,3 +1,2 @@
 import type { Validator } from './types';
 export declare const routerBundleSizesValidator: Validator;
-//# sourceMappingURL=router-bundle-sizes.validator.d.ts.map