@devrev/airsync-sdk 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/logger/logger.test.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_util_1 = require("node:util");
 const constants_1 = require("../common/constants");
-const test_helpers_1 = require("../tests/test-helpers");
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
 const extraction_1 = require("../types/extraction");
 const logger_1 = require("./logger");
 const logger_constants_1 = require("./logger.constants");
@@ -20,24 +21,8 @@ describe(logger_1.Logger.name, () => {
     let mockOptions;
     beforeEach(() => {
         jest.clearAllMocks();
-        mockEvent = (0, test_helpers_1.createEvent)({
-            eventType: extraction_1.EventType.StartExtractingData,
-            eventContextOverrides: {
-                dev_org: 'DEV-test',
-                dev_org_id: 'DEV-test-id',
-                dev_user: 'DEVU-test',
-                dev_user_id: 'DEVU-test-id',
-                external_sync_unit: 'test-unit',
-                external_sync_unit_id: 'test-unit-id',
-                external_sync_unit_name: 'test-unit-name',
-                external_system: 'test-system',
-                external_system_type: 'test-type',
-                import_slug: 'test-import',
-                request_id: 'test-request-id',
-                snap_in_slug: 'test-snap-slug',
-                sync_run: 'test-sync-run',
-                sync_run_id: 'test-sync-run-id',
-            },
+        mockEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
         });
         mockOptions = {
             isLocalDevelopment: false,
@@ -378,6 +363,68 @@ describe(logger_1.getPrintableState.name, () => {
         });
     });
 });
+describe(logger_1.serializeError.name, () => {
+    it('should return the error message string for a standard Error', () => {
+        const error = new Error('something went wrong');
+        expect((0, logger_1.serializeError)(error)).toBe('something went wrong');
+    });
+    it('should include error name for named error types', () => {
+        const typeError = new TypeError('invalid type');
+        expect((0, logger_1.serializeError)(typeError)).toBe('TypeError: invalid type');
+        const rangeError = new RangeError('out of range');
+        expect((0, logger_1.serializeError)(rangeError)).toBe('RangeError: out of range');
+    });
+    it('should return a JSON string for an Axios error', () => {
+        const axiosError = {
+            isAxiosError: true,
+            response: {
+                status: 500,
+                statusText: 'Internal Server Error',
+                data: 'fail',
+                headers: {},
+            },
+            config: { method: 'GET', url: '/api/test', params: undefined },
+        };
+        const result = (0, logger_1.serializeError)(axiosError);
+        expect(typeof result).toBe('string');
+        const parsed = JSON.parse(result);
+        expect(parsed.isAxiosError).toBe(true);
+        expect(parsed.response.status).toBe(500);
+    });
+    it('should return a JSON string for a plain object', () => {
+        const obj = { code: 42, detail: 'bad input' };
+        const result = (0, logger_1.serializeError)(obj);
+        expect(typeof result).toBe('string');
+        expect(JSON.parse(result)).toEqual(obj);
+    });
+    it('should return a JSON string for a string value', () => {
+        expect((0, logger_1.serializeError)('raw string error')).toBe('raw string error');
+    });
+    it('[edge] should handle null without throwing', () => {
+        const result = (0, logger_1.serializeError)(null);
+        expect(typeof result).toBe('string');
+        expect(result).toBe('null');
+    });
+    it('[edge] should handle undefined without throwing', () => {
+        const result = (0, logger_1.serializeError)(undefined);
+        expect(typeof result).toBe('string');
+    });
+    it('[edge] should fall back to extracting own properties for objects that stringify to empty object', () => {
+        // Simulate an error-like object with non-enumerable properties
+        // (e.g. cross-realm Error that fails instanceof check)
+        const errorLike = Object.create(null);
+        Object.defineProperty(errorLike, 'message', {
+            value: 'cross-realm error',
+            enumerable: false,
+        });
+        const result = (0, logger_1.serializeError)(errorLike);
+        expect(typeof result).toBe('string');
+        // Should not be '{}' — that's the whole point of the fix
+        expect(result).not.toBe('{}');
+        // Should have extracted the non-enumerable 'message' property
+        expect(result).toContain('cross-realm error');
+    });
+});
 describe(logger_1.serializeAxiosError.name, () => {
     it('should serialize Axios error with response data', () => {
         // Arrange

package/dist/mappers/mappers.interface.d.ts

@@ -1,11 +1,11 @@
-import { AirdropEvent } from '../types';
+import { AirSyncEvent } from '../types';
 import { DonV2 } from '../types/loading';
 import { WorkerAdapterOptions } from '../types/workers';
 /**
  * Configuration interface for creating a Mappers instance.
  */
 export interface MappersFactoryInterface {
-    event: AirdropEvent;
+    event: AirSyncEvent;
     options?: WorkerAdapterOptions;
 }
 /**
@@ -262,9 +262,9 @@ export interface MappersGetByExternalIdParams {
 export declare enum SyncMapperRecordTargetType {
     ACCESS_CONTROL_ENTRY = "access_control_entry",
     ACCOUNT = "account",
-    AIRDROP_AUTHORIZATION_POLICY = "airdrop_authorization_policy",
-    AIRDROP_FIELD_AUTHORIZATION_POLICY = "airdrop_field_authorization_policy",
-    AIRDROP_PLATFORM_GROUP = "airdrop_platform_group",
+    AIRSYNC_AUTHORIZATION_POLICY = "airdrop_authorization_policy",
+    AIRSYNC_FIELD_AUTHORIZATION_POLICY = "airdrop_field_authorization_policy",
+    AIRSYNC_PLATFORM_GROUP = "airdrop_platform_group",
     ARTICLE = "article",
     ARTIFACT = "artifact",
     CHAT = "chat",

package/dist/mappers/mappers.interface.js

@@ -23,9 +23,9 @@ var SyncMapperRecordTargetType;
 (function (SyncMapperRecordTargetType) {
     SyncMapperRecordTargetType["ACCESS_CONTROL_ENTRY"] = "access_control_entry";
     SyncMapperRecordTargetType["ACCOUNT"] = "account";
-    SyncMapperRecordTargetType["AIRDROP_AUTHORIZATION_POLICY"] = "airdrop_authorization_policy";
-    SyncMapperRecordTargetType["AIRDROP_FIELD_AUTHORIZATION_POLICY"] = "airdrop_field_authorization_policy";
-    SyncMapperRecordTargetType["AIRDROP_PLATFORM_GROUP"] = "airdrop_platform_group";
+    SyncMapperRecordTargetType["AIRSYNC_AUTHORIZATION_POLICY"] = "airdrop_authorization_policy";
+    SyncMapperRecordTargetType["AIRSYNC_FIELD_AUTHORIZATION_POLICY"] = "airdrop_field_authorization_policy";
+    SyncMapperRecordTargetType["AIRSYNC_PLATFORM_GROUP"] = "airdrop_platform_group";
     SyncMapperRecordTargetType["ARTICLE"] = "article";
     SyncMapperRecordTargetType["ARTIFACT"] = "artifact";
     SyncMapperRecordTargetType["CHAT"] = "chat";

package/dist/mappers/mappers.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = require("../common/test-utils");
 const axios_client_internal_1 = require("../http/axios-client-internal");
-const test_helpers_1 = require("../tests/test-helpers");
 const extraction_1 = require("../types/extraction");
 const mappers_1 = require("./mappers");
 const mappers_interface_1 = require("./mappers.interface");
@@ -9,7 +9,6 @@ const mappers_interface_1 = require("./mappers.interface");
 jest.mock('../http/axios-client-internal');
 const mockAxiosClient = axios_client_internal_1.axiosClient;
 describe(mappers_1.Mappers.name, () => {
-    const apiEndpoint = 'test_devrev_endpoint';
     const apiToken = 'test_service_token';
     const syncUnit = 'test_sync_unit';
     const targetId = 'test_target_id';
@@ -17,12 +16,11 @@ describe(mappers_1.Mappers.name, () => {
     const id = 'test_id';
     const externalIds = ['test_external_id'];
     const targets = ['test_target_id'];
-    const mockEvent = (0, test_helpers_1.createEvent)({
-        eventType: extraction_1.EventType.ExtractionDataStart,
-        executionMetadataOverrides: { devrev_endpoint: apiEndpoint },
-        contextOverrides: {
+    const mockEvent = (0, test_utils_1.createMockEvent)(test_utils_1.MOCK_SERVER_DEFAULT_URL, {
+        context: {
             secrets: { service_account_token: apiToken },
         },
+        payload: { event_type: extraction_1.EventType.StartExtractingData },
     });
     const mappers = new mappers_1.Mappers({ event: mockEvent });
     beforeEach(() => {
@@ -38,7 +36,7 @@ describe(mappers_1.Mappers.name, () => {
         // Act
         await mappers.getByTargetId(params);
         // Assert
-        expect(mockAxiosClient.get).toHaveBeenCalledWith(`${apiEndpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
+        expect(mockAxiosClient.get).toHaveBeenCalledWith(`${test_utils_1.MOCK_SERVER_DEFAULT_URL}/internal/airdrop.sync-mapper-record.get-by-target`, {
             headers: {
                 Authorization: apiToken,
             },
@@ -56,7 +54,7 @@ describe(mappers_1.Mappers.name, () => {
         // Act
         await mappers.getByExternalId(params);
         // Assert
-        expect(mockAxiosClient.get).toHaveBeenCalledWith(`${apiEndpoint}/internal/airdrop.sync-mapper-record.get-by-external-id`, {
+        expect(mockAxiosClient.get).toHaveBeenCalledWith(`${test_utils_1.MOCK_SERVER_DEFAULT_URL}/internal/airdrop.sync-mapper-record.get-by-external-id`, {
             headers: {
                 Authorization: apiToken,
             },
@@ -79,7 +77,7 @@ describe(mappers_1.Mappers.name, () => {
         // Act
         await mappers.create(params);
         // Assert
-        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${apiEndpoint}/internal/airdrop.sync-mapper-record.create`, params, {
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${test_utils_1.MOCK_SERVER_DEFAULT_URL}/internal/airdrop.sync-mapper-record.create`, params, {
             headers: {
                 Authorization: apiToken,
             },
@@ -98,7 +96,7 @@ describe(mappers_1.Mappers.name, () => {
         // Act
         await mappers.update(params);
         // Assert
-        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${apiEndpoint}/internal/airdrop.sync-mapper-record.update`, params, {
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${test_utils_1.MOCK_SERVER_DEFAULT_URL}/internal/airdrop.sync-mapper-record.update`, params, {
             headers: {
                 Authorization: apiToken,
             },

package/dist/mock-server/mock-server.d.ts

@@ -0,0 +1,47 @@
+import { RequestInfo, RouteConfig } from './mock-server.interfaces';
+/**
+ * MockServer used in tests to mock internal AirSync endpoints.
+ * This is a simple mock server that listens on a port and responds to requests.
+ * Supports per-test route configuration to simulate different response scenarios.
+ */
+export declare class MockServer {
+    private server;
+    private internalPort;
+    port: number;
+    baseUrl: string;
+    private routeHandlers;
+    private requests;
+    private requestCounts;
+    constructor(port?: number);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    /**
+     * Default route handler for the mock server. Returns { success: true } for
+     * routes that are not explicitly set.
+     */
+    private defaultRouteHandler;
+    private getRouteKey;
+    /**
+     * Configures a route to return a specific status code and optional response body.
+     */
+    setRoute(config: RouteConfig): void;
+    /**
+     * Resets all custom route handlers, restoring all default handlers.
+     * Also clears request tracking data.
+     */
+    resetRoutes(): void;
+    /**
+     * Returns the most recent request or undefined if no requests exist.
+     */
+    getLastRequest(): RequestInfo | undefined;
+    /**
+     * Gets the number of requests made to a specific endpoint.
+     */
+    getRequestCount(method: string, path: string): number;
+    /**
+     * Gets all requests made to a specific endpoint.
+     */
+    getRequests(method: string, path: string): RequestInfo[];
+}
+//# sourceMappingURL=mock-server.d.ts.map

package/dist/mock-server/mock-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.d.ts","sourceRoot":"","sources":["../../src/mock-server/mock-server.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,WAAW,EACX,WAAW,EAEZ,MAAM,0BAA0B,CAAC;AAuElC;;;;GAIG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,YAAY,CAAS;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,aAAa,CAA4B;gBAErC,IAAI,GAAE,MAAiC;IAMtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAkBpB,aAAa;IA+B3B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,WAAW;IAInB;;OAEG;IACI,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAyE1C;;;OAGG;IACI,WAAW,IAAI,IAAI;IAM1B;;OAEG;IACI,cAAc,IAAI,WAAW,GAAG,SAAS;IAOhD;;OAEG;IACI,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAI5D;;OAEG;IACI,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE;CAQhE"}

package/dist/mock-server/mock-server.interfaces.d.ts

@@ -0,0 +1,73 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const DEFAULT_MOCK_SERVER_PORT = 3001;
+export interface ParsedRequest extends IncomingMessage {
+    /** Parsed URL path (without query string) */
+    path: string;
+    /** Parsed JSON body (if any) */
+    body?: unknown;
+}
+export interface MockResponse extends ServerResponse {
+    /** Set response headers from a record */
+    set(headers: Record<string, string>): MockResponse;
+    /** Set the HTTP status code */
+    status(code: number): MockResponse;
+    /** Send a JSON response */
+    json(data: unknown): void;
+    /** Send an empty response */
+    send(): void;
+}
+/**
+ * Configuration for retry simulation behavior.
+ */
+export interface RetryConfig {
+    /** Number of times to return error before succeeding (default: 4) */
+    failureCount?: number;
+    /** 5xx status code to return during failures (default: 500) */
+    errorStatus?: number;
+    /** Optional error response body to send as JSON during failures */
+    errorBody?: unknown;
+    /** Optional headers to send with the error response */
+    headers?: Record<string, string>;
+    /** Optional delay in milliseconds before sending each failure response */
+    delay?: number;
+}
+/**
+ * Configuration object for setting up a route response.
+ */
+export interface RouteConfig {
+    /** The path of the route (e.g., '/callback_url', '/worker_data_url.get') */
+    path: string;
+    /** The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE') */
+    method: string;
+    /** The HTTP status code to return (e.g., 200, 401, 500) */
+    status: number;
+    /** Optional response body to send as JSON */
+    body?: unknown;
+    /** Optional headers to send with the response */
+    headers?: Record<string, string>;
+    /** Optional retry configuration for simulating failures before success */
+    retry?: RetryConfig;
+    /** Optional delay in milliseconds before sending the response */
+    delay?: number;
+}
+/**
+ * Type for custom route handler functions.
+ */
+export type RouteHandler = (req: ParsedRequest, res: MockResponse) => unknown;
+/**
+ * Information about a request received by the mock server.
+ */
+export interface RequestInfo {
+    /** The HTTP method (e.g., 'GET', 'POST') */
+    method: string;
+    /** The full URL path of the request */
+    url: string;
+    /** Optional request body (for POST/PUT requests) */
+    body?: unknown;
+}
+export type RouteHandlers = Map<string, RouteHandler>;
+/**
+ * Type for tracking request counts per route.
+ */
+export type RequestCounts = Map<string, number>;
+//# sourceMappingURL=mock-server.interfaces.d.ts.map

package/dist/mock-server/mock-server.interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.interfaces.d.ts","sourceRoot":"","sources":["../../src/mock-server/mock-server.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEvD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,yCAAyC;IACzC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC;IACnD,+BAA+B;IAC/B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC;IACnC,2BAA2B;IAC3B,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,6BAA6B;IAC7B,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}

package/dist/mock-server/mock-server.interfaces.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MOCK_SERVER_PORT = void 0;
+exports.DEFAULT_MOCK_SERVER_PORT = 3001;

package/dist/mock-server/mock-server.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockServer = void 0;
+const http_1 = require("http");
+const mock_server_interfaces_1 = require("./mock-server.interfaces");
+const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10mb
+/**
+ * Parses the JSON body from an incoming request.
+ */
+async function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                reject(new Error('Request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            if (chunks.length === 0) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                const raw = Buffer.concat(chunks).toString('utf-8');
+                resolve(JSON.parse(raw));
+            }
+            catch (_a) {
+                resolve(undefined);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Wraps a ServerResponse with helper methods (status, json, set, send).
+ */
+function wrapResponse(res) {
+    const mock = res;
+    let statusCode = 200;
+    mock.set = (headers) => {
+        for (const [key, value] of Object.entries(headers)) {
+            res.setHeader(key, value);
+        }
+        return mock;
+    };
+    mock.status = (code) => {
+        statusCode = code;
+        return mock;
+    };
+    mock.json = (data) => {
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    mock.send = () => {
+        res.writeHead(statusCode);
+        res.end();
+    };
+    return mock;
+}
+/**
+ * MockServer used in tests to mock internal AirSync endpoints.
+ * This is a simple mock server that listens on a port and responds to requests.
+ * Supports per-test route configuration to simulate different response scenarios.
+ */
+class MockServer {
+    constructor(port = mock_server_interfaces_1.DEFAULT_MOCK_SERVER_PORT) {
+        this.server = null;
+        this.routeHandlers = new Map();
+        this.requests = [];
+        this.requestCounts = new Map();
+        this.internalPort = port;
+        this.port = port;
+        this.baseUrl = `http://localhost:${this.port}`;
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = (0, http_1.createServer)((req, res) => {
+                this.handleRequest(req, res).catch(() => {
+                    res.writeHead(500);
+                    res.end();
+                });
+            });
+            this.server.listen(this.internalPort, () => {
+                var _a, _b;
+                const actualPort = (_b = (_a = this.server) === null || _a === void 0 ? void 0 : _a.address()) === null || _b === void 0 ? void 0 : _b.port;
+                if (actualPort) {
+                    this.port = actualPort;
+                    this.baseUrl = `http://localhost:${this.port}`;
+                }
+                console.log(`Mock server running on http://localhost:${this.port}.`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.server) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    console.log('Mock server stopped.');
+                    this.server = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    async handleRequest(raw, rawRes) {
+        const req = raw;
+        const res = wrapResponse(rawRes);
+        const urlPath = (req.url || '/').split('?')[0];
+        req.path = urlPath;
+        req.body = await parseJsonBody(req);
+        const requestInfo = Object.assign({ method: req.method || 'GET', url: req.url || urlPath }, (req.body !== undefined && req.body !== null
+            ? { body: req.body }
+            : {}));
+        this.requests.push(requestInfo);
+        const method = (req.method || 'GET').toUpperCase();
+        const key = `${method}:${urlPath}`;
+        const customHandler = this.routeHandlers.get(key);
+        if (customHandler) {
+            customHandler(req, res);
+        }
+        else {
+            this.defaultRouteHandler(req, res);
+        }
+    }
+    /**
+     * Default route handler for the mock server. Returns { success: true } for
+     * routes that are not explicitly set.
+     */
+    defaultRouteHandler(req, res) {
+        if (req.method === 'GET' && req.path === '/worker_data_url.get') {
+            res.status(200).json({
+                state: JSON.stringify({}),
+            });
+        }
+        else if (req.method === 'GET' && req.path === '/internal/snap-ins.get') {
+            res.status(200).json({
+                snap_in: {
+                    imports: [{ name: 'test_import_slug' }],
+                    snap_in_version: { slug: 'test_snap_in_slug' },
+                },
+            });
+        }
+        else if (req.method === 'GET' &&
+            req.path === '/internal/airdrop.artifacts.upload-url') {
+            const artifactId = `artifact-${Date.now()}-${Math.random()
+                .toString(36)
+                .substr(2, 9)}`;
+            res.status(200).json({
+                upload_url: `${this.baseUrl}/file-upload-url`,
+                artifact_id: artifactId,
+                form_data: [],
+            });
+        }
+        else {
+            res.status(200).json({ success: true });
+        }
+    }
+    getRouteKey(method, path) {
+        return `${method.toUpperCase()}:${path}`;
+    }
+    /**
+     * Configures a route to return a specific status code and optional response body.
+     */
+    setRoute(config) {
+        const { path, method, status, body, retry, headers, delay } = config;
+        const key = this.getRouteKey(method, path);
+        if (retry) {
+            this.requestCounts.set(key, 0);
+        }
+        this.routeHandlers.set(key, (req, res) => {
+            const sendResponse = (responseDelay) => {
+                const send = () => {
+                    var _a, _b;
+                    if (retry) {
+                        const currentCount = this.requestCounts.get(key) || 0;
+                        const failureCount = (_a = retry.failureCount) !== null && _a !== void 0 ? _a : 4;
+                        const errorStatus = (_b = retry.errorStatus) !== null && _b !== void 0 ? _b : 500;
+                        if (currentCount < failureCount) {
+                            this.requestCounts.set(key, currentCount + 1);
+                            const sendFailure = () => {
+                                if (retry.headers) {
+                                    res.set(retry.headers);
+                                }
+                                if (retry.errorBody !== undefined) {
+                                    res.status(errorStatus).json(retry.errorBody);
+                                }
+                                else {
+                                    res.status(errorStatus).send();
+                                }
+                            };
+                            if (retry.delay) {
+                                setTimeout(sendFailure, retry.delay);
+                            }
+                            else {
+                                sendFailure();
+                            }
+                        }
+                        else {
+                            this.requestCounts.set(key, currentCount + 1);
+                            if (headers) {
+                                res.set(headers);
+                            }
+                            if (body !== undefined) {
+                                res.status(status).json(body);
+                            }
+                            else {
+                                this.defaultRouteHandler(req, res);
+                            }
+                        }
+                    }
+                    else {
+                        if (headers) {
+                            res.set(headers);
+                        }
+                        if (body !== undefined) {
+                            res.status(status).json(body);
+                        }
+                        else {
+                            res.status(status).send();
+                        }
+                    }
+                };
+                if (responseDelay) {
+                    setTimeout(send, responseDelay);
+                }
+                else {
+                    send();
+                }
+            };
+            sendResponse(delay);
+        });
+    }
+    /**
+     * Resets all custom route handlers, restoring all default handlers.
+     * Also clears request tracking data.
+     */
+    resetRoutes() {
+        this.routeHandlers.clear();
+        this.requestCounts.clear();
+        this.requests = [];
+    }
+    /**
+     * Returns the most recent request or undefined if no requests exist.
+     */
+    getLastRequest() {
+        if (this.requests.length === 0) {
+            return undefined;
+        }
+        return this.requests[this.requests.length - 1];
+    }
+    /**
+     * Gets the number of requests made to a specific endpoint.
+     */
+    getRequestCount(method, path) {
+        return this.getRequests(method, path).length;
+    }
+    /**
+     * Gets all requests made to a specific endpoint.
+     */
+    getRequests(method, path) {
+        const pathWithoutQuery = path.split('?')[0];
+        return this.requests.filter((req) => req.method.toUpperCase() === method.toUpperCase() &&
+            req.url.split('?')[0] === pathWithoutQuery);
+    }
+}
+exports.MockServer = MockServer;