@devrev/ts-adaas 0.0.1 → 0.0.2

package/dist/tests/adapter.test.js

@@ -5,69 +5,118 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
 const adapter_1 = require("../src/adapter");
+const state_1 = require("../src/state");
 const types_1 = require("../src/types");
-const test_helpers_1 = require("./test-helpers");
+const helpers_1 = require("../src/common/helpers");
+jest.mock('axios');
+jest.mock('../src/state');
+jest.mock('../src/common/helpers');
+jest.mock('../src/logging');
+const mockedAxios = axios_1.default;
+const mockedCreateAdapterState = state_1.createAdapterState;
+const mockedGetTimeoutExtractorEventType = helpers_1.getTimeoutExtractorEventType;
 describe('Adapter', () => {
-    it('should be able to create an instance of Adapter', () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionExternalSyncUnitsStart);
-        const adapter = new adapter_1.Adapter(event);
-        expect(adapter).toBeInstanceOf(adapter_1.Adapter);
+    const event = {
+        execution_metadata: {
+            devrev_endpoint: 'devrev_endpoint',
+        },
+        context: {
+            secrets: {
+                service_account_token: 'service_account_token',
+            },
+        },
+        payload: {
+            connection_data: {
+                org_id: 'org_id',
+                org_name: 'org_name',
+                key: 'key',
+                key_type: 'key_type',
+            },
+            event_context: {
+                mode: 'mode',
+                callback_url: 'callback_url',
+                dev_org_id: 'dev_org_id',
+                dev_user_id: 'dev_user_id',
+                external_system_id: 'external_system_id',
+                uuid: 'uuid',
+                sync_run_id: 'sync_run_id',
+                sync_unit_id: 'sync_unit_id',
+                worker_data_url: 'worker_data_url',
+            },
+            event_type: types_1.EventType.ExtractionDataStart,
+        },
+        input_data: {
+            global_values: {},
+            event_sources: {},
+        },
+    };
+    const initialState = {
+        customField: 'initial',
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
     });
-    describe('update', () => {
-        it('should add an artifact to the artifacts array', () => {
-            const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataStart);
-            const adapter = new adapter_1.Adapter(event);
-            const artifact = { id: 'id', item_type: 'item_type', item_count: 1 };
-            adapter.update({ artifact });
-            expect(adapter.getArtifacts()).toContain(artifact);
-        });
-        it('should not add anything if artifact is not provided', () => {
-            const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataStart);
-            const adapter = new adapter_1.Adapter(event);
-            adapter.update({});
-            expect(adapter.getArtifacts()).toHaveLength(0);
+    describe('createAdapter', () => {
+        it('should create an Adapter instance', async () => {
+            const adapterState = new state_1.State(event, initialState);
+            mockedCreateAdapterState.mockResolvedValue(adapterState);
+            const adapter = await (0, adapter_1.createAdapter)(event, initialState, false);
+            expect(adapter).toBeInstanceOf(adapter_1.Adapter);
+            expect(mockedCreateAdapterState).toHaveBeenCalledWith(event, expect.anything());
         });
     });
-    describe('emit', () => {
-        it('should call axios.post with correct parameters - case without error', async () => {
-            const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataStart);
-            const adapter = new adapter_1.Adapter(event);
-            const axiosSpy = jest.spyOn(axios_1.default, 'post').mockResolvedValue({});
-            const newEventType = types_1.ExtractorEventType.ExtractionDataDone;
-            await adapter.emit(newEventType);
-            expect(axiosSpy).toHaveBeenCalledWith(event.payload.event_context.callback_url, expect.objectContaining({
-                event_type: newEventType,
-            }), expect.objectContaining({
-                headers: {
-                    Accept: 'application/json, text/plain, */*',
-                    Authorization: event.context.secrets["service_account_token"],
-                    'Content-Type': 'application/json',
-                },
-            }));
-            axiosSpy.mockRestore();
+    describe('Adapter', () => {
+        let adapter;
+        let adapterState;
+        beforeEach(() => {
+            adapterState = new state_1.State(event, initialState);
+            adapter = new adapter_1.Adapter(event, adapterState, false);
+        });
+        it('should emit event and save state if event type is not stateless', async () => {
+            const data = {};
+            mockedAxios.post.mockResolvedValue({ data: {} });
+            await adapter.emit(types_1.ExtractorEventType.ExtractionDataDone, data);
+            expect(mockedAxios.post).toHaveBeenCalledWith('callback_url', expect.objectContaining({
+                event_type: types_1.ExtractorEventType.ExtractionDataDone,
+            }), expect.any(Object));
+            expect(adapterState.postState).toHaveBeenCalledWith(adapter.state);
+        });
+        it('should not save state if event type is stateless', async () => {
+            const statelessEvent = Object.assign(Object.assign({}, event), { payload: Object.assign(Object.assign({}, event.payload), { event_type: types_1.EventType.ExtractionExternalSyncUnitsStart }) });
+            adapter = new adapter_1.Adapter(statelessEvent, adapterState, false);
+            const data = {};
+            mockedAxios.post.mockResolvedValue({ data: {} });
+            await adapter.emit(types_1.ExtractorEventType.ExtractionExternalSyncUnitsDone, data);
+            expect(mockedAxios.post).toHaveBeenCalledWith('callback_url', expect.objectContaining({
+                event_type: types_1.ExtractorEventType.ExtractionExternalSyncUnitsDone,
+            }), expect.any(Object));
+            expect(adapterState.postState).not.toHaveBeenCalled();
+        });
+        it('should exit adapter on heartbeat timeout', async () => {
+            mockedGetTimeoutExtractorEventType.mockReturnValue({
+                eventType: types_1.ExtractorEventType.ExtractionMetadataError,
+                isError: true,
+            });
+            jest
+                .spyOn(Date, 'now')
+                .mockImplementation(() => adapter['startTime'] + adapter['lambdaTimeout'] + 1);
+            const heartbeatResult = await adapter['heartbeat']();
+            expect(heartbeatResult).toBe(true);
+            expect(mockedGetTimeoutExtractorEventType).toHaveBeenCalledWith(event.payload.event_type);
+            expect(mockedAxios.post).toHaveBeenCalledWith('callback_url', expect.objectContaining({
+                event_type: types_1.ExtractorEventType.ExtractionMetadataError,
+            }), expect.any(Object));
+        });
+        it('should not emit event if adapter is in exit state', async () => {
+            adapter['exit'] = true;
+            await adapter.emit(types_1.ExtractorEventType.ExtractionDataDone);
+            expect(mockedAxios.post).not.toHaveBeenCalled();
         });
-        it('should call axios.post with correct parameters - case with error', async () => {
-            const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataStart);
-            const adapter = new adapter_1.Adapter(event);
-            const axiosSpy = jest.spyOn(axios_1.default, 'post').mockResolvedValue({});
-            const newEventType = types_1.ExtractorEventType.ExtractionDataError;
-            const data = {
-                error: { message: 'some error message' },
-            };
-            await adapter.emit(newEventType, data);
-            expect(axiosSpy).toHaveBeenCalledWith(event.payload.event_context.callback_url, expect.objectContaining({
-                event_type: newEventType,
-                event_data: expect.objectContaining({
-                    error: data.error,
-                }),
-            }), expect.objectContaining({
-                headers: {
-                    Accept: 'application/json, text/plain, */*',
-                    Authorization: event.context.secrets["service_account_token"],
-                    'Content-Type': 'application/json',
-                },
-            }));
-            axiosSpy.mockRestore();
+        it('should handle failed event emission gracefully', async () => {
+            mockedAxios.post.mockRejectedValue(new Error('Network error'));
+            await adapter.emit(types_1.ExtractorEventType.ExtractionDataDone);
+            expect(mockedAxios.post).toHaveBeenCalled();
+            expect(adapter['exit']).toBe(true);
         });
     });
 });

package/dist/tests/demo-extractor.test.js

@@ -2,96 +2,59 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("../src/types");
 const adapter_1 = require("../src/adapter");
-const uploader_1 = require("../src/uploader");
 const demo_extractor_1 = require("../src/demo-extractor");
-const test_helpers_1 = require("./test-helpers");
-jest.mock('../src/adapter');
-jest.mock('../src/uploader');
+const mockEvent = {
+    execution_metadata: {
+        devrev_endpoint: 'devrev_endpoint',
+    },
+    context: {
+        secrets: {
+            service_account_token: 'service_account_token',
+        },
+    },
+    payload: {
+        connection_data: {
+            org_id: 'org_id',
+            org_name: 'org_name',
+            key: 'key',
+            key_type: 'key_type',
+        },
+        event_context: {
+            mode: 'mode',
+            callback_url: 'callback_url',
+            dev_org_id: 'dev_org_id',
+            dev_user_id: 'dev_user_id',
+            external_system_id: 'external_system_id',
+            uuid: 'uuid',
+            sync_run_id: 'sync_run_id',
+            worker_data_url: 'worker_data_url',
+        },
+        event_type: types_1.EventType.ExtractionExternalSyncUnitsStart,
+    },
+    input_data: {
+        global_values: {},
+        event_sources: {},
+    },
+};
 describe('DemoExtractor', () => {
-    let adapterMock;
-    let uploaderMock;
-    let demoExtractor;
-    beforeEach(() => {
-        adapterMock = new adapter_1.Adapter({});
-        uploaderMock = new uploader_1.Uploader('', '');
-        adapter_1.Adapter.mockImplementation(() => adapterMock);
-        uploader_1.Uploader.mockImplementation(() => uploaderMock);
-        demoExtractor = new demo_extractor_1.DemoExtractor();
-    });
-    afterEach(() => {
-        jest.resetAllMocks();
-    });
-    it('should be able to create an instance of DemoExtractor', () => {
+    it('should create a new instance of the DemoExtractor', async () => {
+        const adapter = await (0, adapter_1.createAdapter)(mockEvent, {});
+        const demoExtractor = new demo_extractor_1.DemoExtractor(mockEvent, adapter);
         expect(demoExtractor).toBeInstanceOf(demo_extractor_1.DemoExtractor);
     });
-    it('should emit ExtractionExternalSyncUnitsDone when EventType is ExtractionExternalSyncUnitsStart', async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionExternalSyncUnitsStart);
-        await demoExtractor.run(event);
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionExternalSyncUnitsDone, expect.objectContaining({
+    it('should emit EXTRACTION_EXTERNAL_SYNC_UNITS_DONE with correct payload', async () => {
+        const adapter = await (0, adapter_1.createAdapter)(mockEvent, {});
+        const demoExtractor = new demo_extractor_1.DemoExtractor(mockEvent, adapter);
+        const spy = jest.spyOn(adapter, 'emit');
+        await demoExtractor.run();
+        expect(spy).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionExternalSyncUnitsDone, {
             external_sync_units: [
                 {
                     id: 'devrev',
                     name: 'devrev',
-                    description: 'Loopback for DevRev',
-                    item_count: 0,
+                    description: 'Demo external sync unit',
                 },
             ],
-        }));
-    });
-    it('should emit ExtractionMetadataDone when metadata is uploaded successfully', async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionMetadataStart);
-        const artifact = { id: 'id', item_type: 'item_type', item_count: 1 };
-        uploaderMock.upload.mockResolvedValueOnce({ artifact, error: undefined });
-        await demoExtractor.run(event);
-        expect(adapterMock.update).toHaveBeenCalledWith({ artifact });
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionMetadataDone);
-    });
-    it("should emit ExtractionMetadataError when there's an error uploading metadata", async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionMetadataStart);
-        const error = new Error('Failed to upload metadata');
-        uploaderMock.upload.mockResolvedValueOnce({ artifact: undefined, error });
-        await demoExtractor.run(event);
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionMetadataError, { error });
-    });
-    it('should emit ExtractionDataProgress when data is uploaded successfully', async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataStart);
-        const artifact = { id: 'id', item_type: 'item_type', item_count: 1 };
-        uploaderMock.upload.mockResolvedValueOnce({ artifact, error: undefined });
-        await demoExtractor.run(event);
-        expect(adapterMock.update).toHaveBeenCalledWith({ artifact });
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionDataProgress, { progress: 50 });
-    });
-    it('should emit ExtractionDataDone when data is uploaded successfully', async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataContinue);
-        const artifact = { id: 'id', item_type: 'item_type', item_count: 1 };
-        uploaderMock.upload
-            .mockResolvedValueOnce({ artifact, error: undefined }) // First call to upload (users data)
-            .mockResolvedValueOnce({ artifact, error: undefined }); // Second call to upload (recipe.json)
-        await demoExtractor.run(event);
-        expect(adapterMock.update).toHaveBeenCalledTimes(2);
-        expect(adapterMock.update).toHaveBeenCalledWith({ artifact });
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionDataDone, { progress: 100 });
-    });
-    it("should emit ExtractionDataError when there's an error uploading data", async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionDataStart);
-        const error = new Error('Failed to upload data');
-        uploaderMock.upload.mockResolvedValueOnce({ artifact: undefined, error });
-        await demoExtractor.run(event);
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionDataError, { error });
-    });
-    it('should emit ExtractionAttachmentsDone when attachments are uploaded successfully', async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionAttachmentsStart);
-        const artifact = { id: 'id', item_type: 'item_type', item_count: 1 };
-        uploaderMock.upload.mockResolvedValueOnce({ artifact, error: undefined });
-        await demoExtractor.run(event);
-        expect(adapterMock.update).toHaveBeenCalledWith({ artifact });
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionAttachmentsProgress);
-    });
-    it("should emit ExtractionAttachmentsError when there's an error uploading attachments", async () => {
-        const event = (0, test_helpers_1.createAirdropEvent)(types_1.EventType.ExtractionAttachmentsStart);
-        const error = new Error('Failed to upload attachment');
-        uploaderMock.upload.mockResolvedValueOnce({ artifact: undefined, error });
-        await demoExtractor.run(event);
-        expect(adapterMock.emit).toHaveBeenCalledWith(types_1.ExtractorEventType.ExtractionAttachmentsError, { error });
+        });
     });
 });

package/dist/tests/state.test.js

@@ -0,0 +1,100 @@
+"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 state_1 = require("../src/state");
+const types_1 = require("../src/types");
+const constants_1 = require("../src/common/constants");
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('AdapterState', () => {
+    const event = {
+        execution_metadata: {
+            devrev_endpoint: 'devrev_endpoint',
+        },
+        context: {
+            secrets: {
+                service_account_token: 'service_account_token',
+            },
+        },
+        payload: {
+            connection_data: {
+                org_id: 'org_id',
+                org_name: 'org_name',
+                key: 'key',
+                key_type: 'key_type',
+            },
+            event_context: {
+                mode: 'mode',
+                callback_url: 'callback_url',
+                dev_org_id: 'dev_org_id',
+                dev_user_id: 'dev_user_id',
+                external_system_id: 'external_system_id',
+                uuid: 'uuid',
+                sync_run_id: 'sync_run_id',
+                sync_unit_id: 'sync_unit_id',
+                worker_data_url: 'worker_data_url',
+            },
+            event_type: types_1.EventType.ExtractionDataStart,
+        },
+        input_data: {
+            global_values: {},
+            event_sources: {},
+        },
+    };
+    const initialState = {
+        customField: 'initial',
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('createAdapterState', () => {
+        it('should create an AdapterState instance', async () => {
+            const adapterState = await (0, state_1.createAdapterState)(event, initialState);
+            expect(adapterState).toBeInstanceOf(state_1.State);
+            expect(adapterState.state).toEqual(Object.assign(Object.assign({}, initialState), { lastSyncStarted: '', lastSuccessfulSyncStarted: '' }));
+        });
+        it('should fetch state if event type is not stateless', async () => {
+            const spy = jest.spyOn(state_1.State.prototype, 'fetchState');
+            await (0, state_1.createAdapterState)(event, initialState);
+            expect(spy).toHaveBeenCalled();
+        });
+        it('should not fetch state if event type is stateless', async () => {
+            const statelessEvent = Object.assign(Object.assign({}, event), { payload: Object.assign(Object.assign({}, event.payload), { event_type: constants_1.STATELESS_EVENT_TYPES[0] }) });
+            const spy = jest.spyOn(state_1.State.prototype, 'fetchState');
+            await (0, state_1.createAdapterState)(statelessEvent, initialState);
+            expect(spy).not.toHaveBeenCalled();
+        });
+    });
+    describe('AdapterState', () => {
+        let adapterState;
+        beforeEach(() => {
+            adapterState = new state_1.State(event, initialState);
+        });
+        it('should initialize with given state', () => {
+            expect(adapterState.state).toEqual(Object.assign(Object.assign({}, initialState), { lastSyncStarted: '', lastSuccessfulSyncStarted: '' }));
+        });
+        it('should update state via postState', async () => {
+            const newState = Object.assign(Object.assign({}, initialState), { customField: 'updated' });
+            mockedAxios.post.mockResolvedValue({ data: {} });
+            await adapterState.postState(newState);
+            expect(adapterState.state).toEqual(newState);
+            expect(mockedAxios.post).toHaveBeenCalledWith('worker_data_url.update', { state: JSON.stringify(newState) }, {
+                headers: { Authorization: 'service_account_token' },
+                params: { sync_unit: 'sync_unit_id' },
+            });
+        });
+        it('should handle non-404 error in fetchState', async () => {
+            const error = new Error('Network error');
+            mockedAxios.post.mockRejectedValue(error);
+            const state = await adapterState.fetchState(initialState);
+            expect(state).toBe(error);
+            expect(mockedAxios.post).toHaveBeenCalledWith('worker_data_url.get', {}, {
+                headers: { Authorization: 'service_account_token' },
+                params: { sync_unit: 'sync_unit_id' },
+            });
+        });
+    });
+});

package/dist/tests/uploader.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uploader_1 = require("../src/uploader");
+// mock uploader.upload method
+jest.mock('../src/uploader', () => {
+    return {
+        Uploader: jest.fn().mockImplementation(() => {
+            return {
+                upload: jest.fn().mockResolvedValue({
+                    artifact: { key: 'value' },
+                    error: undefined,
+                }),
+            };
+        }),
+    };
+});
+describe('uploader.ts', () => {
+    const uploader = new uploader_1.Uploader('https://example.com', 'test-token', false);
+    it('should upload the file to the DevRev platform and return the artifact information', async () => {
+        const filename = 'filename';
+        const entity = 'entity';
+        const fetchedObjects = [{ key: 'value' }];
+        const uploadResponse = await uploader.upload(filename, entity, fetchedObjects);
+        expect(uploadResponse).toEqual({
+            artifact: { key: 'value' },
+            error: undefined,
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/src/index.js",

package/dist/src/adapter/index.test.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("../types");
-const index_1 = require("./index");
-jest.useFakeTimers();
-const defaultEvent = {
-    context: {
-        secrets: {
-            service_account_token: 'mockToken',
-        },
-    },
-    payload: {
-        connection_data: {
-            org_id: 'mockOrgId',
-            org_name: 'mockOrgName',
-            key: 'mockKey',
-            key_type: 'mockKeyType',
-        },
-        event_context: {
-            mode: 'INITIAL',
-            uuid: 'mockUuid',
-            callback_url: 'mockCallbackUrl',
-            dev_org_id: 'DEV-TESTORG',
-            dev_user_id: 'DEV-TESTUSER',
-            external_system_id: 'TESTSYSTEM',
-            sync_run_id: 'mockSyncRunId',
-        },
-        event_type: types_1.EventType.ExtractionExternalSyncUnitsStart,
-    },
-    execution_metadata: {
-        devrev_endpoint: 'http://api.dev.devrev-eng.ai',
-    },
-    input_data: {
-        global_values: {},
-        event_sources: {},
-    },
-};
-describe('Adapter', () => {
-    let adapter;
-    beforeEach(() => {
-        // Initialize the Adapter instance with mock data
-        adapter = new index_1.Adapter(defaultEvent);
-    });
-    afterEach(async () => {
-        // Clear all timers
-        jest.clearAllTimers();
-        // Clear all instances
-        jest.clearAllMocks();
-    });
-    it('should add artifact to the list of artifacts', async () => {
-        const artifact = {
-            id: 'mockId',
-            item_type: 'mockItemType',
-            item_count: 1,
-            // Mock artifact data
-        };
-        adapter.update({ artifact: artifact });
-        const artifacts = adapter.getArtifacts();
-        expect(artifacts).toContain(artifact);
-        // Run all timers
-        jest.runAllTimers();
-    });
-    it('should set extractor state if provided', async () => {
-        const state = {
-            testing: false,
-        };
-        adapter = new index_1.Adapter(Object.assign({}, defaultEvent), state);
-        expect(adapter['extractorState']).toEqual(state);
-        const newState = {
-            testing: true,
-        };
-        adapter.update({ extractor_state: newState });
-        expect(adapter['extractorState']).toEqual(newState);
-        // Run all timers
-        jest.runAllTimers();
-    });
-    it('update both an artifact and extractor state', async () => {
-        const artifact = {
-            id: 'mockId',
-            item_type: 'mockItemType',
-            item_count: 1,
-        };
-        const state = {
-            willUpdateToTrue: false,
-            willAdd4: 0,
-        };
-        adapter.update({ artifact: artifact, extractor_state: state });
-        const artifacts = adapter.getArtifacts();
-        expect(artifacts).toContain(artifact);
-        expect(adapter['extractorState']).toEqual(state);
-        const newState = {
-            willUpdateToTrue: true,
-            willAdd4: 4,
-            newField: 'newField',
-        };
-        const newArtifact = {
-            id: 'newMockId',
-            item_type: 'newMockItemType',
-            item_count: 2,
-        };
-        adapter.update({ artifact: newArtifact, extractor_state: newState });
-        // Run all timers
-        jest.runAllTimers();
-    });
-});

package/dist/src/demo-extractor/recipe.json

@@ -1,37 +0,0 @@
-{
-    "initial_object_mappings": [
-        {
-            "external_type": "contacts",
-            "possible_targets": {
-                "rev_user": {}
-            },
-            "default_target": "rev_user",
-            "allow_item_type_decisions": true
-        },
-        {
-            "external_type": "users",
-            "possible_targets": {
-                "dev_user": {}
-            },
-            "default_target": "dev_user",
-            "allow_item_type_decisions": true
-        },
-        {
-            "external_type": "tickets",
-            "possible_targets": {
-                "work.ticket": {}
-            },
-            "default_target": "work.ticket",
-            "allow_item_type_decisions": true
-        },
-        {
-            "external_type": "conversations",
-            "possible_targets": {
-                "comment": {}
-            },
-            "default_target": "comment",
-            "allow_item_type_decisions": true
-        }
-    ],
-    "external_system_short_name": "source-system"
-}

package/dist/tests/helpers.test.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("../src/adapter/helpers");
-const types_1 = require("../src/types");
-describe('createFormData', () => {
-    it('should create a FormData object', () => {
-        const preparedArtifact = {
-            form_data: [{ key: 'key', value: 'value' }],
-        };
-        const fetchedObjects = [{ key: 'value' }];
-        const formData = (0, helpers_1.createFormData)(preparedArtifact, fetchedObjects);
-        expect(formData).toBeInstanceOf(FormData);
-        expect(formData.get('key')).toBe('value');
-    });
-});
-describe('createArtifact', () => {
-    it('should create an Artifact object', () => {
-        const preparedArtifact = { id: 'id' };
-        const fetchedObjects = [{ key: 'value' }];
-        const entity = 'entity';
-        const artifact = (0, helpers_1.createArtifact)(preparedArtifact, fetchedObjects, entity);
-        expect(artifact).toEqual({
-            item_count: 1,
-            id: 'id',
-            item_type: 'entity',
-        });
-    });
-});
-describe('getTimeoutExtractorEventType', () => {
-    it('should return the correct ExtractorEventType', () => {
-        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionMetadataStart)).toBe(types_1.ExtractorEventType.ExtractionMetadataError);
-        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionDataStart)).toBe(types_1.ExtractorEventType.ExtractionDataProgress);
-        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionDataContinue)).toBe(types_1.ExtractorEventType.ExtractionDataProgress);
-        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionAttachmentsStart)).toBe(types_1.ExtractorEventType.ExtractionAttachmentsProgress);
-        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionAttachmentsContinue)).toBe(types_1.ExtractorEventType.ExtractionAttachmentsProgress);
-        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionExternalSyncUnitsStart)).toBe(types_1.ExtractorEventType.ExtractionExternalSyncUnitsError);
-    });
-});

package/dist/tests/test-helpers.d.ts

@@ -1,2 +0,0 @@
-import { EventType, AirdropEvent } from '../src/types';
-export declare function createAirdropEvent(event_type: EventType, overrides?: object): AirdropEvent;