@devrev/airsync-sdk 2.0.0-beta.0

package/dist/common/event-type-translation.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateIncomingEventType = translateIncomingEventType;
+exports.translateExtractorEventType = translateExtractorEventType;
+exports.translateLoaderEventType = translateLoaderEventType;
+exports.translateOutgoingEventType = translateOutgoingEventType;
+const extraction_1 = require("../types/extraction");
+const loading_1 = require("../types/loading");
+/**
+ * Maps old incoming event type strings to new EventType enum values.
+ * This ensures backwards compatibility when the platform sends old event types.
+ * @param eventTypeString The raw event type string from the platform
+ * @returns The translated EventType enum value
+ */
+function translateIncomingEventType(eventTypeString) {
+    // Create a reverse mapping from OLD string values to NEW enum member names
+    const eventTypeMap = {
+        // Old extraction event types from platform -> New enum members
+        [extraction_1.EventType.ExtractionExternalSyncUnitsStart]: extraction_1.EventType.StartExtractingExternalSyncUnits,
+        [extraction_1.EventType.ExtractionMetadataStart]: extraction_1.EventType.StartExtractingMetadata,
+        [extraction_1.EventType.ExtractionDataStart]: extraction_1.EventType.StartExtractingData,
+        [extraction_1.EventType.ExtractionDataContinue]: extraction_1.EventType.ContinueExtractingData,
+        [extraction_1.EventType.ExtractionDataDelete]: extraction_1.EventType.StartDeletingExtractorState,
+        [extraction_1.EventType.ExtractionAttachmentsStart]: extraction_1.EventType.StartExtractingAttachments,
+        [extraction_1.EventType.ExtractionAttachmentsContinue]: extraction_1.EventType.ContinueExtractingAttachments,
+        [extraction_1.EventType.ExtractionAttachmentsDelete]: extraction_1.EventType.StartDeletingExtractorAttachmentsState,
+        // New extraction event types (already correct, map to new enum members)
+        [extraction_1.EventType.StartExtractingExternalSyncUnits]: extraction_1.EventType.StartExtractingExternalSyncUnits,
+        [extraction_1.EventType.StartExtractingMetadata]: extraction_1.EventType.StartExtractingMetadata,
+        [extraction_1.EventType.StartExtractingData]: extraction_1.EventType.StartExtractingData,
+        [extraction_1.EventType.ContinueExtractingData]: extraction_1.EventType.ContinueExtractingData,
+        [extraction_1.EventType.StartDeletingExtractorState]: extraction_1.EventType.StartDeletingExtractorState,
+        [extraction_1.EventType.StartExtractingAttachments]: extraction_1.EventType.StartExtractingAttachments,
+        [extraction_1.EventType.ContinueExtractingAttachments]: extraction_1.EventType.ContinueExtractingAttachments,
+        [extraction_1.EventType.StartDeletingExtractorAttachmentsState]: extraction_1.EventType.StartDeletingExtractorAttachmentsState,
+        // Loading events
+        [extraction_1.EventType.StartLoadingData]: extraction_1.EventType.StartLoadingData,
+        [extraction_1.EventType.ContinueLoadingData]: extraction_1.EventType.ContinueLoadingData,
+        [extraction_1.EventType.StartLoadingAttachments]: extraction_1.EventType.StartLoadingAttachments,
+        [extraction_1.EventType.ContinueLoadingAttachments]: extraction_1.EventType.ContinueLoadingAttachments,
+        [extraction_1.EventType.StartDeletingLoaderState]: extraction_1.EventType.StartDeletingLoaderState,
+        [extraction_1.EventType.StartDeletingLoaderAttachmentState]: extraction_1.EventType.StartDeletingLoaderAttachmentState,
+        // Unknown
+        [extraction_1.EventType.UnknownEventType]: extraction_1.EventType.UnknownEventType,
+    };
+    const translated = eventTypeMap[eventTypeString];
+    if (!translated) {
+        console.warn(`Unknown event type received: ${eventTypeString}. This may indicate a new event type or a typo.`);
+        // Return the original string cast as EventType as a fallback
+        return eventTypeString;
+    }
+    return translated;
+}
+/**
+ * Translates ExtractorEventType enum values by converting old enum members to new ones.
+ * Old enum members are deprecated and should be replaced with new ones.
+ */
+function translateExtractorEventType(eventType) {
+    var _a;
+    // Map old enum members to new enum members
+    const stringValue = eventType;
+    const mapping = {
+        // Old string values -> New enum members
+        [extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsDone]: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone,
+        [extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsError]: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
+        [extraction_1.ExtractorEventType.ExtractionMetadataDone]: extraction_1.ExtractorEventType.MetadataExtractionDone,
+        [extraction_1.ExtractorEventType.ExtractionMetadataError]: extraction_1.ExtractorEventType.MetadataExtractionError,
+        [extraction_1.ExtractorEventType.ExtractionDataProgress]: extraction_1.ExtractorEventType.DataExtractionProgress,
+        [extraction_1.ExtractorEventType.ExtractionDataDelay]: extraction_1.ExtractorEventType.DataExtractionDelayed,
+        [extraction_1.ExtractorEventType.ExtractionDataDone]: extraction_1.ExtractorEventType.DataExtractionDone,
+        [extraction_1.ExtractorEventType.ExtractionDataError]: extraction_1.ExtractorEventType.DataExtractionError,
+        [extraction_1.ExtractorEventType.ExtractionDataDeleteDone]: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
+        [extraction_1.ExtractorEventType.ExtractionDataDeleteError]: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
+        [extraction_1.ExtractorEventType.ExtractionAttachmentsProgress]: extraction_1.ExtractorEventType.AttachmentExtractionProgress,
+        [extraction_1.ExtractorEventType.ExtractionAttachmentsDelay]: extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
+        [extraction_1.ExtractorEventType.ExtractionAttachmentsDone]: extraction_1.ExtractorEventType.AttachmentExtractionDone,
+        [extraction_1.ExtractorEventType.ExtractionAttachmentsError]: extraction_1.ExtractorEventType.AttachmentExtractionError,
+        [extraction_1.ExtractorEventType.ExtractionAttachmentsDeleteDone]: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
+        [extraction_1.ExtractorEventType.ExtractionAttachmentsDeleteError]: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
+    };
+    // If there's a mapping, use it; otherwise return original (already new)
+    return (_a = mapping[stringValue]) !== null && _a !== void 0 ? _a : eventType;
+}
+/**
+ * Translates LoaderEventType enum values by converting old enum members to new ones.
+ * Old enum members are deprecated and should be replaced with new ones.
+ */
+function translateLoaderEventType(eventType) {
+    var _a;
+    // Map old enum members to new enum members
+    const stringValue = eventType;
+    const mapping = {
+        // Old string values -> New enum members
+        [loading_1.LoaderEventType.DataLoadingDelay]: loading_1.LoaderEventType.DataLoadingDelayed,
+        [loading_1.LoaderEventType.AttachmentsLoadingProgress]: loading_1.LoaderEventType.AttachmentLoadingProgress,
+        [loading_1.LoaderEventType.AttachmentsLoadingDelayed]: loading_1.LoaderEventType.AttachmentLoadingDelayed,
+        [loading_1.LoaderEventType.AttachmentsLoadingDone]: loading_1.LoaderEventType.AttachmentLoadingDone,
+        [loading_1.LoaderEventType.AttachmentsLoadingError]: loading_1.LoaderEventType.AttachmentLoadingError,
+    };
+    // If there's a mapping, use it; otherwise return original (already new)
+    return (_a = mapping[stringValue]) !== null && _a !== void 0 ? _a : eventType;
+}
+/**
+ * Translates any outgoing event type (Extractor or Loader) to ensure new event types are used.
+ */
+function translateOutgoingEventType(eventType) {
+    // Check if it's an ExtractorEventType by checking if the value exists in ExtractorEventType
+    if (Object.values(extraction_1.ExtractorEventType).includes(eventType)) {
+        return translateExtractorEventType(eventType);
+    }
+    // Otherwise treat as LoaderEventType
+    if (Object.values(loading_1.LoaderEventType).includes(eventType)) {
+        return translateLoaderEventType(eventType);
+    }
+    // If neither, return as-is
+    return eventType;
+}

package/dist/common/helpers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Gets the library version from the package.json file.
+ * @returns {string} The library version
+ */
+export declare function getLibraryVersion(): any;
+/**
+ * Sleeps for a given number of milliseconds.
+ * @param {number} ms - The number of milliseconds to sleep
+ * @returns {Promise<void>} A promise that resolves after the given number of milliseconds
+ */
+export declare function sleep(ms: number): Promise<unknown>;
+/**
+ * Truncates a filename if it exceeds the maximum allowed length.
+ * @param {string} filename - The filename to truncate
+ * @returns {string} The truncated filename
+ */
+export declare function truncateFilename(filename: string): string;
+/**
+ * MemoryInfo is an interface that represents the memory usage information.
+ * @interface MemoryInfo
+ * @property {string} rssUsedMB - The RSS used in MB
+ * @property {string} rssUsedPercent - The RSS used percentage
+ * @property {string} heapUsedPercent - The heap used percentage
+ * @property {string} externalMB - The external memory used in MB
+ * @property {string} arrayBuffersMB - The array buffers memory used in MB
+ * @property {string} formattedMessage - The formatted message
+ */
+export interface MemoryInfo {
+    rssUsedMB: string;
+    rssUsedPercent: string;
+    heapUsedPercent: string;
+    externalMB: string;
+    arrayBuffersMB: string;
+    formattedMessage: string;
+}
+/**
+ * Gets the memory usage information.
+ * @returns {MemoryInfo} The memory usage information
+ */
+export declare function getMemoryUsage(): MemoryInfo;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/common/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/common/helpers.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAgB,iBAAiB,QAiBhC;AAED;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAGrC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBzD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,UAAU,CAmD3C"}

package/dist/common/helpers.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibraryVersion = getLibraryVersion;
+exports.sleep = sleep;
+exports.truncateFilename = truncateFilename;
+exports.getMemoryUsage = getMemoryUsage;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const v8 = __importStar(require("v8"));
+const constants_1 = require("./constants");
+/**
+ * Gets the library version from the package.json file.
+ * @returns {string} The library version
+ */
+function getLibraryVersion() {
+    var _a;
+    try {
+        const version = (_a = JSON.parse((0, fs_1.readFileSync)(path.resolve(__dirname, '../../package.json'), 'utf8'))) === null || _a === void 0 ? void 0 : _a.version;
+        if (version) {
+            return version;
+        }
+        return '';
+    }
+    catch (error) {
+        console.error('Error reading adaas library version from package.json', error);
+        return '';
+    }
+}
+/**
+ * Sleeps for a given number of milliseconds.
+ * @param {number} ms - The number of milliseconds to sleep
+ * @returns {Promise<void>} A promise that resolves after the given number of milliseconds
+ */
+async function sleep(ms) {
+    console.log(`Sleeping for ${ms}ms.`);
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Truncates a filename if it exceeds the maximum allowed length.
+ * @param {string} filename - The filename to truncate
+ * @returns {string} The truncated filename
+ */
+function truncateFilename(filename) {
+    // If the filename is already within the limit, return it as is.
+    if (filename.length <= constants_1.MAX_DEVREV_FILENAME_LENGTH) {
+        return filename;
+    }
+    console.warn(`Filename length exceeds the maximum limit of ${constants_1.MAX_DEVREV_FILENAME_LENGTH} characters. Truncating filename.`);
+    const extension = filename.slice(-constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH);
+    // Calculate how many characters are available for the name part after accounting for the extension and "..."
+    const availableNameLength = constants_1.MAX_DEVREV_FILENAME_LENGTH - constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH - 3; // -3 for "..."
+    // Truncate the name part and add an ellipsis
+    const truncatedFilename = filename.slice(0, availableNameLength);
+    return `${truncatedFilename}...${extension}`;
+}
+/**
+ * Gets the memory usage information.
+ * @returns {MemoryInfo} The memory usage information
+ */
+function getMemoryUsage() {
+    try {
+        const memUsage = process.memoryUsage();
+        const heapStats = v8.getHeapStatistics();
+        const rssUsedMB = memUsage.rss / 1024 / 1024;
+        const heapLimitMB = heapStats.heap_size_limit / 1024 / 1024;
+        const effectiveMemoryLimitMB = heapLimitMB;
+        // Calculate heap values for consistent format
+        const heapUsedMB = heapStats.used_heap_size / 1024 / 1024;
+        const heapTotalMB = heapStats.heap_size_limit / 1024 / 1024;
+        // Calculate external and buffer values (critical for detecting stream leaks)
+        const externalMB = memUsage.external / 1024 / 1024;
+        const arrayBuffersMB = memUsage.arrayBuffers / 1024 / 1024;
+        // Critical percentages for OOM detection
+        const rssUsedPercent = ((rssUsedMB / effectiveMemoryLimitMB) * 100).toFixed(2) + '%';
+        const heapUsedPercent = ((heapStats.used_heap_size / heapStats.heap_size_limit) * 100).toFixed(2) + '%';
+        // Detailed message showing RSS breakdown for leak detection
+        const formattedMessage = `Memory: RSS ${rssUsedMB.toFixed(2)}/${effectiveMemoryLimitMB.toFixed(2)}MB (${rssUsedPercent}) [Heap ${heapUsedMB.toFixed(2)}/${heapTotalMB.toFixed(2)}MB (${heapUsedPercent}) + External ${externalMB.toFixed(2)}MB + Buffers ${arrayBuffersMB.toFixed(2)}MB].`;
+        return {
+            rssUsedMB: rssUsedMB.toFixed(2),
+            rssUsedPercent,
+            heapUsedPercent,
+            externalMB: externalMB.toFixed(2),
+            arrayBuffersMB: arrayBuffersMB.toFixed(2),
+            formattedMessage,
+        };
+    }
+    catch (err) {
+        console.warn('Error retrieving memory usage', err);
+        throw err;
+    }
+}

package/dist/common/install-initial-domain-mapping.d.ts

@@ -0,0 +1,4 @@
+import { AirdropEvent } from '../types/extraction';
+import { InitialDomainMapping } from '../types/common';
+export declare function installInitialDomainMapping(event: AirdropEvent, initialDomainMappingJson: InitialDomainMapping): Promise<void>;
+//# sourceMappingURL=install-initial-domain-mapping.d.ts.map

package/dist/common/install-initial-domain-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-initial-domain-mapping.d.ts","sourceRoot":"","sources":["../../src/common/install-initial-domain-mapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,YAAY,EACnB,wBAAwB,EAAE,oBAAoB,GAC7C,OAAO,CAAC,IAAI,CAAC,CA0Ff"}

package/dist/common/install-initial-domain-mapping.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installInitialDomainMapping = installInitialDomainMapping;
+const axios_client_internal_1 = require("../http/axios-client-internal");
+const logger_1 = require("../logger/logger");
+async function installInitialDomainMapping(event, initialDomainMappingJson) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const devrevEndpoint = event.execution_metadata.devrev_endpoint;
+    const devrevToken = event.context.secrets.service_account_token;
+    const snapInId = event.context.snap_in_id;
+    if (!initialDomainMappingJson) {
+        console.warn('No initial domain mapping found.');
+        return;
+    }
+    // Get snap-in details
+    const snapInResponse = await axios_client_internal_1.axiosClient.get(devrevEndpoint + '/internal/snap-ins.get', {
+        headers: {
+            Authorization: devrevToken,
+        },
+        params: {
+            id: snapInId,
+        },
+    });
+    const importSlug = (_d = (_c = (_b = (_a = snapInResponse.data) === null || _a === void 0 ? void 0 : _a.snap_in) === null || _b === void 0 ? void 0 : _b.imports) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.name;
+    const snapInSlug = (_g = (_f = (_e = snapInResponse.data) === null || _e === void 0 ? void 0 : _e.snap_in) === null || _f === void 0 ? void 0 : _f.snap_in_version) === null || _g === void 0 ? void 0 : _g.slug;
+    if (!importSlug || !snapInSlug) {
+        const errorMessage = `No import slug or snap-in slug found. Snap-in response: ${snapInResponse.data}`;
+        throw new Error(errorMessage);
+    }
+    const startingRecipeBlueprint = initialDomainMappingJson === null || initialDomainMappingJson === void 0 ? void 0 : initialDomainMappingJson.starting_recipe_blueprint;
+    // Try to create a recipe blueprint
+    let recipeBlueprintId;
+    if (startingRecipeBlueprint &&
+        Object.keys(startingRecipeBlueprint).length !== 0) {
+        try {
+            const recipeBlueprintResponse = await axios_client_internal_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.blueprints.create`, Object.assign({}, startingRecipeBlueprint), {
+                headers: {
+                    Authorization: devrevToken,
+                },
+            });
+            recipeBlueprintId = recipeBlueprintResponse.data.recipe_blueprint.id;
+            console.log('Successfully created recipe blueprint with id: ' + recipeBlueprintId);
+        }
+        catch (error) {
+            console.warn('Error while creating recipe blueprint. Continuing without it.', (0, logger_1.serializeError)(error));
+        }
+    }
+    // Install the initial domain mappings
+    const additionalMappings = initialDomainMappingJson.additional_mappings || {};
+    const initialDomainMappingInstallResponse = await axios_client_internal_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, Object.assign(Object.assign({ external_system_type: 'ADaaS', import_slug: importSlug, snap_in_slug: snapInSlug }, (recipeBlueprintId && {
+        starting_recipe_blueprint: recipeBlueprintId,
+    })), additionalMappings), {
+        headers: {
+            Authorization: devrevToken,
+        },
+    });
+    console.log('Successfully installed initial domain mapping', initialDomainMappingInstallResponse.data);
+}

package/dist/common/install-initial-domain-mapping.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=install-initial-domain-mapping.test.d.ts.map

package/dist/common/install-initial-domain-mapping.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-initial-domain-mapping.test.d.ts","sourceRoot":"","sources":["../../src/common/install-initial-domain-mapping.test.ts"],"names":[],"mappings":""}

package/dist/common/install-initial-domain-mapping.test.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+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 install_initial_domain_mapping_1 = require("./install-initial-domain-mapping");
+// Mock dependencies
+jest.mock('axios', () => (Object.assign(Object.assign({}, jest.requireActual('axios')), { isAxiosError: jest.fn() })));
+jest.mock('../http/axios-client-internal', () => {
+    const originalModule = jest.requireActual('../http/axios-client-internal');
+    return Object.assign(Object.assign({}, originalModule), { axiosClient: {
+            get: jest.fn(),
+            post: jest.fn(),
+        } });
+});
+jest.mock('../logger/logger');
+const mockAxiosClient = axios_client_internal_1.axiosClient;
+const mockIsAxiosError = axios_1.default.isAxiosError;
+describe(install_initial_domain_mapping_1.installInitialDomainMapping.name, () => {
+    // Create mock objects
+    const mockEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
+    const mockInitialDomainMapping = {
+        starting_recipe_blueprint: {
+            name: 'Test Recipe Blueprint',
+            description: 'Test description',
+        },
+        additional_mappings: {
+            custom_field: 'custom_value',
+        },
+    };
+    const mockSnapInResponse = {
+        data: {
+            snap_in: {
+                imports: [{ name: 'import-slug-123' }],
+                snap_in_version: { slug: 'snap-in-slug-123' },
+            },
+        },
+    };
+    const mockEndpoint = 'http://localhost:3001';
+    const mockToken = 'test_token';
+    // After each test, clear all mocks to prevent state from leaking.
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should successfully install initial domain mapping with recipe blueprint', async () => {
+        // Mock successful snap-in response
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        // Mock successful recipe blueprint creation
+        const mockRecipeBlueprintResponse = {
+            data: {
+                recipe_blueprint: {
+                    id: 'recipe-blueprint-123',
+                },
+            },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockRecipeBlueprintResponse);
+        // Mock successful domain mapping installation
+        const mockDomainMappingResponse = {
+            data: {
+                success: true,
+                mapping_id: 'mapping-123',
+            },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping);
+        // Verify snap-in details request
+        expect(mockAxiosClient.get).toHaveBeenCalledWith(`${mockEndpoint}/internal/snap-ins.get`, {
+            headers: {
+                Authorization: mockToken,
+            },
+            params: {
+                id: 'test_snap_in_id',
+            },
+        });
+        // Verify recipe blueprint creation
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${mockEndpoint}/internal/airdrop.recipe.blueprints.create`, {
+            name: 'Test Recipe Blueprint',
+            description: 'Test description',
+        }, {
+            headers: {
+                Authorization: mockToken,
+            },
+        });
+        // Verify domain mapping installation
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${mockEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, {
+            external_system_type: 'ADaaS',
+            import_slug: 'import-slug-123',
+            snap_in_slug: 'snap-in-slug-123',
+            starting_recipe_blueprint: 'recipe-blueprint-123',
+            custom_field: 'custom_value',
+        }, {
+            headers: {
+                Authorization: mockToken,
+            },
+        });
+    });
+    it('should successfully install without recipe blueprint when not provided', async () => {
+        const mappingWithoutBlueprint = {
+            additional_mappings: {
+                custom_field: 'custom_value',
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        const mockDomainMappingResponse = {
+            data: { success: true },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mappingWithoutBlueprint);
+        // Should only make one POST request (no recipe blueprint creation)
+        expect(mockAxiosClient.post).toHaveBeenCalledTimes(1);
+        expect(mockAxiosClient.post).toHaveBeenCalledWith(`${mockEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, {
+            external_system_type: 'ADaaS',
+            import_slug: 'import-slug-123',
+            snap_in_slug: 'snap-in-slug-123',
+            custom_field: 'custom_value',
+        }, {
+            headers: {
+                Authorization: mockToken,
+            },
+        });
+    });
+    it('should handle empty starting_recipe_blueprint object', async () => {
+        const mappingWithEmptyBlueprint = {
+            starting_recipe_blueprint: {},
+            additional_mappings: {
+                custom_field: 'custom_value',
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        const mockDomainMappingResponse = {
+            data: { success: true },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mappingWithEmptyBlueprint);
+        // Should only make one POST request (no recipe blueprint creation for empty object)
+        expect(mockAxiosClient.post).toHaveBeenCalledTimes(1);
+    });
+    it('[edge] should return early with warning when initial domain mapping is null', async () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, null);
+        expect(mockAxiosClient.get).not.toHaveBeenCalled();
+        expect(mockAxiosClient.post).not.toHaveBeenCalled();
+    });
+    it('[edge] should return early with warning when initial domain mapping is undefined', async () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, undefined);
+        expect(mockAxiosClient.get).not.toHaveBeenCalled();
+        expect(mockAxiosClient.post).not.toHaveBeenCalled();
+    });
+    it('[edge] should throw error when import slug is missing', async () => {
+        const snapInResponseWithoutImport = {
+            data: {
+                snap_in: {
+                    imports: [],
+                    snap_in_version: { slug: 'snap-in-slug-123' },
+                },
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(snapInResponseWithoutImport);
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow();
+    });
+    it('[edge] should throw error when snap-in slug is missing', async () => {
+        const snapInResponseWithoutSlug = {
+            data: {
+                snap_in: {
+                    imports: [{ name: 'import-slug-123' }],
+                    snap_in_version: {},
+                },
+            },
+        };
+        mockAxiosClient.get.mockResolvedValueOnce(snapInResponseWithoutSlug);
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow();
+    });
+    it('should handle the error during recipe blueprint creation', async () => {
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        const genericError = new Error('Generic error during blueprint creation');
+        // Mock axios.isAxiosError to return false
+        mockIsAxiosError.mockReturnValue(false);
+        mockAxiosClient.post.mockRejectedValueOnce(genericError);
+        const mockDomainMappingResponse = {
+            data: { success: true },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockDomainMappingResponse);
+        await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping);
+        // Should still proceed with domain mapping installation
+        expect(mockAxiosClient.post).toHaveBeenCalledTimes(2);
+    });
+    it('should propagate error from domain mapping installation', async () => {
+        mockAxiosClient.get.mockResolvedValueOnce(mockSnapInResponse);
+        // Mock successful recipe blueprint creation
+        const mockRecipeBlueprintResponse = {
+            data: {
+                recipe_blueprint: {
+                    id: 'recipe-blueprint-123',
+                },
+            },
+        };
+        mockAxiosClient.post.mockResolvedValueOnce(mockRecipeBlueprintResponse);
+        const domainMappingError = new Error('Domain mapping installation failed');
+        mockAxiosClient.post.mockRejectedValueOnce(domainMappingError);
+        await expect((0, install_initial_domain_mapping_1.installInitialDomainMapping)(mockEvent, mockInitialDomainMapping)).rejects.toThrow();
+    });
+});

package/dist/deprecated/adapter/index.d.ts

@@ -0,0 +1,62 @@
+import { AirdropEvent, EventData, ExtractorEventType } from '../../types/extraction';
+import { Artifact } from '../../uploader/uploader.interfaces';
+import { AdapterState } from '../../state/state.interfaces';
+import { State } from '../../state/state';
+/**
+ * Adapter class is used to interact with Airdrop platform. The class provides
+ * utilities to
+ *  - emit control events to the platform
+ *  - update the state of the extractor
+ *  - set the last saved state in case of a timeout
+ *
+ * @class Adapter
+ * @constructor
+ * @deprecated
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param {object=} initialState - The initial state of the adapter
+ * @param {boolean=} isLocalDevelopment - A flag to indicate if the adapter is being used in local development
+ */
+/**
+ *  Creates an adapter instance.
+ *
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param initialState
+ * @param {boolean=} isLocalDevelopment - A flag to indicate if the adapter is being used in local development
+ * @return  The adapter instance
+ */
+export declare function createAdapter<ConnectorState>(event: AirdropEvent, initialState: ConnectorState, isLocalDevelopment?: boolean): Promise<Adapter<ConnectorState>>;
+export declare class Adapter<ConnectorState> {
+    private adapterState;
+    private _artifacts;
+    private event;
+    private callbackUrl;
+    private devrevToken;
+    private startTime;
+    private heartBeatFn;
+    private exit;
+    private lambdaTimeout;
+    private heartBeatInterval;
+    constructor(event: AirdropEvent, adapterState: State<ConnectorState>, isLocalDevelopment?: boolean);
+    get state(): AdapterState<ConnectorState>;
+    set state(value: AdapterState<ConnectorState>);
+    get artifacts(): Artifact[];
+    set artifacts(value: Artifact[]);
+    /**
+     *  Emits an event to the platform.
+     *
+     * @param {ExtractorEventType} newEventType - The event type to be emitted
+     * @param {EventData=} data - The data to be sent with the event
+     */
+    emit(newEventType: ExtractorEventType, data?: EventData): Promise<void>;
+    /**
+     * Exit the adapter. This will stop the heartbeat and no
+     * further events will be emitted.
+     */
+    private exitAdapter;
+    /**
+     * Heartbeat function to check if the lambda is about to timeout.
+     * @returns true if 10 minutes have passed since the start of the lambda.
+     */
+    private heartbeat;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/deprecated/adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deprecated/adapter/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAE9D,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAK5D,OAAO,EAAE,KAAK,EAAsB,MAAM,mBAAmB,CAAC;AAI9D;;;;;;;;;;;;;GAaG;AAEH;;;;;;;GAOG;AAEH,wBAAsB,aAAa,CAAC,cAAc,EAChD,KAAK,EAAE,YAAY,EACnB,YAAY,EAAE,cAAc,EAC5B,kBAAkB,GAAE,OAAe,oCAiBpC;AAED,qBAAa,OAAO,CAAC,cAAc;IACjC,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,UAAU,CAAa;IAE/B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAA4C;IAC/D,OAAO,CAAC,IAAI,CAAkB;IAC9B,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,iBAAiB,CAAqB;gBAG5C,KAAK,EAAE,YAAY,EACnB,YAAY,EAAE,KAAK,CAAC,cAAc,CAAC,EACnC,kBAAkB,GAAE,OAAe;IAwBrC,IAAI,KAAK,IAAI,YAAY,CAAC,cAAc,CAAC,CAExC;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,YAAY,CAAC,cAAc,CAAC,EAE5C;IAED,IAAI,SAAS,IAAI,QAAQ,EAAE,CAE1B;IAED,IAAI,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,EAE9B;IAED;;;;;OAKG;IACG,IAAI,CAAC,YAAY,EAAE,kBAAkB,EAAE,IAAI,CAAC,EAAE,SAAS;IAoD7D;;;OAGG;IACH,OAAO,CAAC,WAAW;IAInB;;;OAGG;YACW,SAAS;CAiBxB"}