@devrev/ts-adaas 0.0.1

package/dist/src/uploader/index.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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");
+/**
+ * Uploader class is used to upload files to the DevRev platform.
+ * The class provides utilities to
+ * - prepare artifact
+ * - upload artifact
+ * - return the artifact information to the platform
+ *
+ * @class Uploader
+ * @constructor
+ * @param {string} endpoint - The endpoint of the DevRev platform
+ * @param {string} token - The token to authenticate with the DevRev platform
+ */
+class Uploader {
+    constructor(endpoint, token) {
+        this.betaDevrevSdk = typescript_sdk_1.client.setupBeta({
+            endpoint,
+            token,
+        });
+        this.publicDevrevSdk = typescript_sdk_1.client.setup({ endpoint, token });
+    }
+    /**
+     *
+     *  Uploads the file to the DevRev platform. The file is uploaded to the platform
+     *  and the artifact information is returned.
+     *
+     * @param {string} filename - The name of the file to be uploaded
+     * @param {string} entity - The entity type of the file to be uploaded
+     * @param {object[] | object} fetchedObjects - The objects to be uploaded
+     * @param filetype - The type of the file to be uploaded
+     * @returns {Promise<UploadResponse>} - The response object containing the artifact information
+     */
+    async upload(filename, entity, fetchedObjects, filetype = 'application/jsonl+json') {
+        const preparedArtifact = await this.prepareArtifact(filename, filetype);
+        if (!preparedArtifact) {
+            return {
+                artifact: undefined,
+                error: { message: 'Error while preparing artifact' },
+            };
+        }
+        const uploadedArtifact = await this.uploadToArtifact(preparedArtifact, fetchedObjects);
+        if (!uploadedArtifact) {
+            return {
+                artifact: undefined,
+                error: { message: 'Error while uploading artifact' },
+            };
+        }
+        // If file was successfully uploaded we want to post data about that file when emitting
+        const itemCount = Array.isArray(fetchedObjects) ? fetchedObjects.length : 1;
+        const artifact = {
+            id: preparedArtifact.id,
+            item_type: entity,
+            item_count: itemCount,
+        };
+        return { artifact, error: undefined };
+    }
+    async prepareArtifact(filename, filetype) {
+        try {
+            const response = await this.betaDevrevSdk.artifactsPrepare({
+                file_name: filename,
+                file_type: filetype,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error('Error while fetching upload url: ' + error);
+        }
+    }
+    async uploadToArtifact(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    preparedArtifact, fetchedObjects) {
+        const formData = (0, helpers_1.createFormData)(preparedArtifact, fetchedObjects);
+        try {
+            const response = await axios_1.default.post(preparedArtifact.url, formData, {
+                headers: {
+                    'Content-Type': 'multipart/form',
+                },
+            });
+            return response;
+        }
+        catch (error) {
+            console.error('Error while uploading artifact: ' + error);
+            return null;
+        }
+    }
+}
+exports.Uploader = Uploader;

package/dist/tests/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/adapter.test.js

@@ -0,0 +1,73 @@
+"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 adapter_1 = require("../src/adapter");
+const types_1 = require("../src/types");
+const test_helpers_1 = require("./test-helpers");
+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);
+    });
+    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('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();
+        });
+        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();
+        });
+    });
+});

package/dist/tests/demo-extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,97 @@
+"use strict";
+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');
+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', () => {
+        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({
+            external_sync_units: [
+                {
+                    id: 'devrev',
+                    name: 'devrev',
+                    description: 'Loopback for DevRev',
+                    item_count: 0,
+                },
+            ],
+        }));
+    });
+    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/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/helpers.test.js

@@ -0,0 +1,38 @@
+"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

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

package/dist/tests/test-helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAirdropEvent = void 0;
+function createAirdropEvent(event_type, overrides) {
+    return Object.assign({ 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',
+            },
+            event_type,
+        }, input_data: {
+            global_values: {},
+            event_sources: {},
+        } }, overrides);
+}
+exports.createAirdropEvent = createAirdropEvent;

package/dist/tests/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/types.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('Airdrop event types', () => {
+    describe('ExternalSyncUnit', () => {
+        test('should have the required properties', () => {
+            const externalSyncUnit = {
+                id: '123',
+                name: 'test-unit-name',
+                description: 'test-unit-description',
+                item_count: 0,
+            };
+            expect(externalSyncUnit).toHaveProperty('id');
+            expect(externalSyncUnit).toHaveProperty('name');
+            expect(externalSyncUnit).toHaveProperty('description');
+            expect(externalSyncUnit).toHaveProperty('item_count');
+        });
+    });
+    describe('EventContextIn', () => {
+        test('should have the required properties', () => {
+            const eventContext = {
+                mode: 'INITIAL',
+                callback_url: 'https://test.com',
+                dev_org_id: 'DEV-123',
+                dev_user_id: 'DEVU-123',
+                external_system_id: '123',
+                sync_run_id: '123',
+                uuid: '123',
+            };
+            expect(eventContext).toHaveProperty('mode');
+            expect(eventContext).toHaveProperty('callback_url');
+            expect(eventContext).toHaveProperty('dev_org_id');
+            expect(eventContext).toHaveProperty('dev_user_id');
+            expect(eventContext).toHaveProperty('external_system_id');
+            expect(eventContext).toHaveProperty('uuid');
+        });
+    });
+    describe('ConnectionData', () => {
+        test('should have the required properties', () => {
+            const connectionData = {
+                org_id: '123',
+                org_name: 'test-org-name',
+                key: 'test-key',
+                key_type: 'test-key-type',
+            };
+            expect(connectionData).toHaveProperty('org_id');
+            expect(connectionData).toHaveProperty('org_name');
+            expect(connectionData).toHaveProperty('key');
+            expect(connectionData).toHaveProperty('key_type');
+        });
+    });
+    describe('ErrorRecord', () => {
+        test('should have the required properties', () => {
+            const errorRecord = {
+                message: 'test-message',
+            };
+            expect(errorRecord).toHaveProperty('message');
+        });
+    });
+    describe('Artifact', () => {
+        test('should have the required properties', () => {
+            const artifact = {
+                item_count: 0,
+                id: '123',
+                item_type: 'test-item-type',
+            };
+            expect(artifact).toHaveProperty('item_type');
+            expect(artifact).toHaveProperty('id');
+            expect(artifact).toHaveProperty('item_count');
+        });
+    });
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@devrev/ts-adaas",
+  "version": "0.0.1",
+  "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
+  "type": "commonjs",
+  "main": "./dist/src/index.js",
+  "typings": "./dist/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/index.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint .  --fix",
+    "test": "jest --forceExit --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devrev/adaas-sdk.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [],
+  "author": "devrev",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@devrev/typescript-sdk": "^1.1.27",
+    "axios": "^1.5.1",
+    "js-jsonl": "^1.1.1",
+    "ts-node": "^10.9.2"
+  },
+  "files": [
+    "dist"
+  ]
+}