@devrev/ts-adaas 0.0.1 → 0.0.3

package/dist/src/uploader/index.js

@@ -1,4 +1,27 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,7 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uploader = void 0;
 const axios_1 = __importDefault(require("axios"));
 const typescript_sdk_1 = require("@devrev/typescript-sdk");
-const helpers_1 = require("../adapter/helpers");
+const fs_1 = __importStar(require("fs"));
+const helpers_1 = require("../common/helpers");
 /**
  * Uploader class is used to upload files to the DevRev platform.
  * The class provides utilities to
@@ -18,14 +42,15 @@ const helpers_1 = require("../adapter/helpers");
  * @constructor
  * @param {string} endpoint - The endpoint of the DevRev platform
  * @param {string} token - The token to authenticate with the DevRev platform
+ * @param {boolean} local - Flag to indicate if the uploader should upload to the file-system.
  */
 class Uploader {
-    constructor(endpoint, token) {
+    constructor(endpoint, token, local = false) {
         this.betaDevrevSdk = typescript_sdk_1.client.setupBeta({
             endpoint,
             token,
         });
-        this.publicDevrevSdk = typescript_sdk_1.client.setup({ endpoint, token });
+        this.local = local;
     }
     /**
      *
@@ -39,6 +64,9 @@ class Uploader {
      * @returns {Promise<UploadResponse>} - The response object containing the artifact information
      */
     async upload(filename, entity, fetchedObjects, filetype = 'application/jsonl+json') {
+        if (this.local) {
+            this.downloadToLocal(filename, fetchedObjects);
+        }
         const preparedArtifact = await this.prepareArtifact(filename, filetype);
         if (!preparedArtifact) {
             return {
@@ -60,6 +88,7 @@ class Uploader {
             item_type: entity,
             item_count: itemCount,
         };
+        console.log(`Artifact uploaded successfully: ${artifact.id}`);
         return { artifact, error: undefined };
     }
     async prepareArtifact(filename, filetype) {
@@ -71,7 +100,8 @@ class Uploader {
             return response.data;
         }
         catch (error) {
-            throw new Error('Error while fetching upload url: ' + error);
+            console.error('Error while preparing artifact: ' + error);
+            return null;
         }
     }
     async uploadToArtifact(
@@ -91,5 +121,32 @@ class Uploader {
             return null;
         }
     }
+    async downloadToLocal(filePath, fetchedObjects) {
+        console.log(`Uploading ${filePath} to local file system`);
+        try {
+            if (!fs_1.default.existsSync('extracted_files')) {
+                fs_1.default.mkdirSync('extracted_files');
+            }
+            const timestamp = new Date().getTime();
+            const fileHandle = await fs_1.promises.open(`extracted_files/${timestamp}_${filePath}`, 'w');
+            let objArray = [];
+            if (!Array.isArray(fetchedObjects)) {
+                objArray.push(fetchedObjects);
+            }
+            else {
+                objArray = fetchedObjects;
+            }
+            for (const jsonObject of objArray) {
+                const jsonLine = JSON.stringify(jsonObject) + '\n';
+                await fileHandle.write(jsonLine);
+            }
+            await fileHandle.close();
+            console.log('Data successfully written to', filePath);
+        }
+        catch (error) {
+            console.error('Error writing data to file:', error);
+            return Promise.reject(error);
+        }
+    }
 }
 exports.Uploader = Uploader;

package/dist/tests/adapter.helpers.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("../src/common/helpers");
+const types_1 = require("../src/types");
+describe('adapter.helpers.ts', () => {
+    it("should create a FormData object with the correct 'key' and 'value'", () => {
+        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');
+    });
+    it("should create a FormData object with the correct 'file' key", () => {
+        const preparedArtifact = {
+            form_data: [{ key: 'key', value: 'value' }],
+        };
+        const fetchedObjects = [{ key: 'value' }];
+        const formData = (0, helpers_1.createFormData)(preparedArtifact, fetchedObjects);
+        expect(formData.get('file')).toBeDefined();
+    });
+    it("should create an Artifact object with the correct 'item_count', 'id', and 'item_type'", () => {
+        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',
+        });
+    });
+    it('should return the correct ExtractorEventType', () => {
+        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionMetadataStart)).toStrictEqual({
+            eventType: types_1.ExtractorEventType.ExtractionMetadataError,
+            isError: true,
+        });
+        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionDataStart)).toStrictEqual({
+            eventType: types_1.ExtractorEventType.ExtractionDataProgress,
+            isError: false,
+        });
+        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionDataContinue)).toStrictEqual({
+            eventType: types_1.ExtractorEventType.ExtractionDataProgress,
+            isError: false,
+        });
+        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionAttachmentsStart)).toStrictEqual({
+            eventType: types_1.ExtractorEventType.ExtractionAttachmentsProgress,
+            isError: false,
+        });
+        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionAttachmentsContinue)).toStrictEqual({
+            eventType: types_1.ExtractorEventType.ExtractionAttachmentsProgress,
+            isError: false,
+        });
+        expect((0, helpers_1.getTimeoutExtractorEventType)(types_1.EventType.ExtractionExternalSyncUnitsStart)).toStrictEqual({
+            eventType: types_1.ExtractorEventType.ExtractionExternalSyncUnitsError,
+            isError: true,
+        });
+    });
+});

package/dist/tests/adapter.test.js

@@ -5,69 +5,119 @@ 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',
+            },
+            snap_in_version_id: 'snap_in_version_id',
+        },
+        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,60 @@
 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',
+        },
+        snap_in_version_id: 'snap_in_version_id',
+    },
+    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,101 @@
+"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',
+            },
+            snap_in_version_id: 'snap_in_version_id',
+        },
+        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.3",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/src/index.js",