@devrev/ts-adaas 1.4.2 → 1.5.1

package/README.md

@@ -4,8 +4,7 @@
 
 ## Overview
 
-The Airdrop SDK for TypeScript helps developers build snap-ins that integrate with DevRev’s Airdrop platform. 
-This SDK simplifies the workflow for handling data extraction and loading, event-driven actions, state management, and artifact handling.
+The Airdrop SDK for TypeScript helps developers build snap-ins that integrate with DevRev’s Airdrop platform. This SDK simplifies the workflow for handling data extraction and loading, event-driven actions, state management, and artifact handling.
 
 It provides features such as:
 

package/dist/common/constants.d.ts

@@ -11,3 +11,4 @@ export declare const AIRDROP_DEFAULT_ITEM_TYPES: {
     SSOR_ATTACHMENT: string;
 };
 export declare const LIBRARY_VERSION: any;
+export declare const DEFAULT_SLEEP_DELAY_MS = 180000;

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = void 0;
+exports.DEFAULT_SLEEP_DELAY_MS = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = void 0;
 const extraction_1 = require("../types/extraction");
 const helpers_1 = require("./helpers");
 exports.STATELESS_EVENT_TYPES = [
@@ -39,3 +39,4 @@ exports.AIRDROP_DEFAULT_ITEM_TYPES = {
     SSOR_ATTACHMENT: 'ssor_attachment',
 };
 exports.LIBRARY_VERSION = (0, helpers_1.getLibraryVersion)();
+exports.DEFAULT_SLEEP_DELAY_MS = 180000; // 3 minutes

package/dist/common/helpers.d.ts

@@ -16,3 +16,4 @@ export declare function addReportToLoaderReport({ loaderReports, report, }: {
 }): LoaderReport[];
 export declare function getCircularReplacer(): (key: any, value: any) => any;
 export declare function getLibraryVersion(): any;
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/common/helpers.js

@@ -39,6 +39,7 @@ exports.getFilesToLoad = getFilesToLoad;
 exports.addReportToLoaderReport = addReportToLoaderReport;
 exports.getCircularReplacer = getCircularReplacer;
 exports.getLibraryVersion = getLibraryVersion;
+exports.sleep = sleep;
 const extraction_1 = require("../types/extraction");
 const loading_1 = require("../types/loading");
 const fs_1 = require("fs");
@@ -176,3 +177,7 @@ function getLibraryVersion() {
         return '';
     }
 }
+function sleep(ms) {
+    console.log(`Sleeping for ${ms}ms.`);
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/mappers/mappers.d.ts

@@ -1,8 +1,8 @@
 import { AxiosResponse } from 'axios';
 import { MappersFactoryInterface, MappersCreateParams, MappersCreateResponse, MappersGetByTargetIdParams, MappersGetByTargetIdResponse, MappersUpdateParams, MappersUpdateResponse } from './mappers.interface';
 export declare class Mappers {
-    private endpoint;
-    private token;
+    private devrevApiEndpoint;
+    private devrevApiToken;
     constructor({ event }: MappersFactoryInterface);
     getByTargetId(params: MappersGetByTargetIdParams): Promise<AxiosResponse<MappersGetByTargetIdResponse>>;
     create(params: MappersCreateParams): Promise<AxiosResponse<MappersCreateResponse>>;

package/dist/mappers/mappers.js

@@ -4,29 +4,29 @@ exports.Mappers = void 0;
 const axios_client_1 = require("../http/axios-client");
 class Mappers {
     constructor({ event }) {
-        this.endpoint = event.execution_metadata.devrev_endpoint;
-        this.token = event.context.secrets.service_account_token;
+        this.devrevApiEndpoint = event.execution_metadata.devrev_endpoint;
+        this.devrevApiToken = event.context.secrets.service_account_token;
     }
     async getByTargetId(params) {
         const { sync_unit, target } = params;
-        return axios_client_1.axiosClient.get(`${this.endpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
+        return axios_client_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
             headers: {
-                Authorization: this.token,
+                Authorization: this.devrevApiToken,
             },
             params: { sync_unit, target },
         });
     }
     async create(params) {
-        return axios_client_1.axiosClient.post(`${this.endpoint}/internal/airdrop.sync-mapper-record.create`, params, {
+        return axios_client_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.create`, params, {
             headers: {
-                Authorization: this.token,
+                Authorization: this.devrevApiToken,
             },
         });
     }
     async update(params) {
-        return axios_client_1.axiosClient.post(`${this.endpoint}/internal/airdrop.sync-mapper-record.update`, params, {
+        return axios_client_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.update`, params, {
             headers: {
-                Authorization: this.token,
+                Authorization: this.devrevApiToken,
             },
         });
     }

package/dist/types/extraction.d.ts

@@ -77,6 +77,13 @@ export interface ExternalSyncUnit {
     item_count?: number;
     item_type?: string;
 }
+/**
+ * InitialSyncScope is an enum that defines the different scopes of initial sync that can be used by the external extractor.
+ */
+export declare enum InitialSyncScope {
+    FULL_HISTORY = "full-history",
+    TIME_SCOPED = "time-scoped"
+}
 /**
  * EventContextIn is an interface that defines the structure of the input event context that is sent to the external extractor from ADaaS.
  * @deprecated
@@ -114,7 +121,7 @@ export interface EventContextOut {
     sync_unit?: string;
 }
 /**
- * EventContext is an interface that defines the structure of the event context that is sent to and from the external connector.
+ * EventContext is an interface that defines the structure of the event context that is sent to the external connector from Airdrop.
  */
 export interface EventContext {
     callback_url: string;
@@ -127,9 +134,12 @@ export interface EventContext {
     external_sync_unit_name: string;
     external_system: string;
     external_system_type: string;
+    extract_from?: string;
     import_slug: string;
+    initial_sync_scope?: InitialSyncScope;
     mode: string;
     request_id: string;
+    reset_extraction?: boolean;
     snap_in_slug: string;
     snap_in_version_id: string;
     sync_run: string;

package/dist/types/extraction.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncMode = exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
+exports.InitialSyncScope = exports.SyncMode = exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
 /**
  * EventType is an enum that defines the different types of events that can be sent to the external extractor from ADaaS.
  * The external extractor can use these events to know what to do next in the extraction process.
@@ -70,3 +70,11 @@ var SyncMode;
     SyncMode["INCREMENTAL"] = "INCREMENTAL";
     SyncMode["LOADING"] = "LOADING";
 })(SyncMode || (exports.SyncMode = SyncMode = {}));
+/**
+ * InitialSyncScope is an enum that defines the different scopes of initial sync that can be used by the external extractor.
+ */
+var InitialSyncScope;
+(function (InitialSyncScope) {
+    InitialSyncScope["FULL_HISTORY"] = "full-history";
+    InitialSyncScope["TIME_SCOPED"] = "time-scoped";
+})(InitialSyncScope || (exports.InitialSyncScope = InitialSyncScope = {}));

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

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

package/dist/types/extraction.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extraction_1 = require("./extraction");
+const test_helpers_1 = require("../tests/test-helpers");
+describe('EventContext type tests', () => {
+    const baseEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
+    it('should handle context without optional fields', () => {
+        const event = Object.assign({}, baseEvent);
+        // If this compiles, the test passes
+        expect(event).toBeDefined();
+    });
+    it('should handle context with all optional fields', () => {
+        const event = Object.assign({}, baseEvent);
+        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z', initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED, reset_extraction: true });
+        // Test with all optionals present
+        expect(event).toBeDefined();
+    });
+    it('should handle partial optional fields', () => {
+        const event = Object.assign({}, baseEvent);
+        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z' });
+        expect(event).toBeDefined();
+    });
+});

package/dist/uploader/uploader.d.ts

@@ -1,11 +1,13 @@
 import { NormalizedAttachment } from '../repo/repo.interfaces';
-import { ArtifactsPrepareResponse, UploadResponse, UploaderFactoryInterface } from './uploader.interfaces';
+import { UploadResponse, UploaderFactoryInterface, ArtifactToUpload } from './uploader.interfaces';
 import { AxiosResponse } from 'axios';
 export declare class Uploader {
     private event;
     private isLocalDevelopment?;
     private devrevApiEndpoint;
     private devrevApiToken;
+    private requestId;
+    private defaultHeaders;
     constructor({ event, options }: UploaderFactoryInterface);
     /**
      * Uploads the fetched objects to the DevRev platform.
@@ -17,9 +19,10 @@ export declare class Uploader {
      * or error information if there was an error
      */
     upload(itemType: string, fetchedObjects: object[] | object): Promise<UploadResponse>;
-    prepareArtifact(filename: string, fileType: string): Promise<ArtifactsPrepareResponse | void>;
-    private uploadToArtifact;
-    streamToArtifact(preparedArtifact: ArtifactsPrepareResponse, fileStreamResponse: any): Promise<AxiosResponse | void>;
+    getArtifactUploadUrl(filename: string, fileType: string): Promise<ArtifactToUpload | void>;
+    uploadArtifact(artifact: ArtifactToUpload, file: Buffer): Promise<AxiosResponse | void>;
+    streamArtifact(artifact: ArtifactToUpload, fileStream: any): Promise<AxiosResponse | void>;
+    confirmArtifactUpload(artifactId: string): Promise<AxiosResponse | void>;
     getAttachmentsFromArtifactId({ artifact, }: {
         artifact: string;
     }): Promise<{

package/dist/uploader/uploader.interfaces.d.ts

@@ -25,6 +25,17 @@ export interface ArtifactsPrepareResponse {
         value: string;
     }[];
 }
+/**
+ * ArtifactToUpload is an interface that defines the structure of the response from the get upload url endpoint.
+ */
+export interface ArtifactToUpload {
+    upload_url: string;
+    artifact_id: string;
+    form_data: {
+        key: string;
+        value: string;
+    }[];
+}
 /**
  * UploadResponse is an interface that defines the structure of the response from upload through Uploader.
  */

package/dist/uploader/uploader.js

@@ -49,7 +49,11 @@ class Uploader {
         this.event = event;
         this.devrevApiEndpoint = event.execution_metadata.devrev_endpoint;
         this.devrevApiToken = event.context.secrets.service_account_token;
+        this.requestId = event.payload.event_context.request_id;
         this.isLocalDevelopment = options === null || options === void 0 ? void 0 : options.isLocalDevelopment;
+        this.defaultHeaders = {
+            Authorization: `Bearer ${this.devrevApiToken}`,
+        };
     }
     /**
      * Uploads the fetched objects to the DevRev platform.
@@ -64,7 +68,7 @@ class Uploader {
         if (this.isLocalDevelopment) {
             await this.downloadToLocal(itemType, fetchedObjects);
         }
-        // compress the fetched objects to a gzipped jsonl object
+        // Compress the fetched objects to a gzipped jsonl object
         const file = this.compressGzip(js_jsonl_1.jsonl.stringify(fetchedObjects));
         if (!file) {
             return {
@@ -73,58 +77,65 @@ class Uploader {
         }
         const filename = itemType + '.jsonl.gz';
         const fileType = 'application/x-gzip';
-        // prepare the artifact for uploading
-        const preparedArtifact = await this.prepareArtifact(filename, fileType);
+        // Get upload url
+        const preparedArtifact = await this.getArtifactUploadUrl(filename, fileType);
         if (!preparedArtifact) {
             return {
-                error: { message: 'Error while preparing artifact.' },
+                error: { message: 'Error while getting artifact upload URL.' },
             };
         }
-        // upload the file to the prepared artifact
-        const uploadedArtifact = await this.uploadToArtifact(preparedArtifact, file);
-        if (!uploadedArtifact) {
+        // Upload prepared artifact to the given url
+        const uploadItemResponse = await this.uploadArtifact(preparedArtifact, file);
+        if (!uploadItemResponse) {
             return {
                 error: { message: 'Error while uploading artifact.' },
             };
         }
-        // return the artifact information to the platform
+        // Confirm upload
+        const confirmArtifactUploadResponse = await this.confirmArtifactUpload(preparedArtifact.artifact_id);
+        if (!confirmArtifactUploadResponse) {
+            return {
+                error: { message: 'Error while confirming artifact upload.' },
+            };
+        }
+        // Return the artifact information to the platform
         const artifact = {
-            id: preparedArtifact.id,
+            id: preparedArtifact.artifact_id,
             item_type: itemType,
             item_count: Array.isArray(fetchedObjects) ? fetchedObjects.length : 1,
         };
-        console.log('Successful upload of artifact', artifact);
         return { artifact };
     }
-    async prepareArtifact(filename, fileType) {
+    async getArtifactUploadUrl(filename, fileType) {
+        const url = `${this.devrevApiEndpoint}/internal/airdrop.artifacts.upload-url`;
         try {
-            const response = await axios_client_1.axiosClient.post(`${this.devrevApiEndpoint}/artifacts.prepare`, {
-                file_name: filename,
-                file_type: fileType,
-            }, {
-                headers: {
-                    Authorization: `Bearer ${this.devrevApiToken}`,
+            const response = await axios_client_1.axiosClient.get(url, {
+                headers: Object.assign({}, this.defaultHeaders),
+                params: {
+                    request_id: this.requestId,
+                    file_type: fileType,
+                    file_name: filename,
                 },
             });
             return response.data;
         }
         catch (error) {
             if (axios_client_1.axios.isAxiosError(error)) {
-                console.error('Error while preparing artifact.', (0, logger_1.serializeAxiosError)(error));
+                console.error('Error while getting artifact upload URL.', (0, logger_1.serializeAxiosError)(error));
             }
             else {
-                console.error('Error while preparing artifact.', error);
+                console.error('Error while getting artifact upload URL.', error);
             }
         }
     }
-    async uploadToArtifact(preparedArtifact, file) {
+    async uploadArtifact(artifact, file) {
         const formData = new form_data_1.default();
-        for (const field of preparedArtifact.form_data) {
-            formData.append(field.key, field.value);
+        for (const field in artifact.form_data) {
+            formData.append(field, artifact.form_data[field]);
         }
         formData.append('file', file);
         try {
-            const response = await axios_client_1.axiosClient.post(preparedArtifact.url, formData, {
+            const response = await axios_client_1.axiosClient.post(artifact.upload_url, formData, {
                 headers: Object.assign({}, formData.getHeaders()),
             });
             return response;
@@ -138,19 +149,19 @@ class Uploader {
             }
         }
     }
-    async streamToArtifact(preparedArtifact, fileStreamResponse) {
+    async streamArtifact(artifact, fileStream) {
         const formData = new form_data_1.default();
-        for (const field of preparedArtifact.form_data) {
-            formData.append(field.key, field.value);
+        for (const field in artifact.form_data) {
+            formData.append(field, artifact.form_data[field]);
         }
-        formData.append('file', fileStreamResponse.data);
-        if (fileStreamResponse.headers['content-length'] > constants_1.MAX_DEVREV_ARTIFACT_SIZE) {
+        formData.append('file', fileStream.data);
+        if (fileStream.headers['content-length'] > constants_1.MAX_DEVREV_ARTIFACT_SIZE) {
             console.warn(`File size exceeds the maximum limit of ${constants_1.MAX_DEVREV_ARTIFACT_SIZE} bytes.`);
             return;
         }
         try {
-            const response = await axios_client_1.axiosClient.post(preparedArtifact.url, formData, {
-                headers: Object.assign(Object.assign({}, formData.getHeaders()), (!fileStreamResponse.headers['content-length']
+            const response = await axios_client_1.axiosClient.post(artifact.upload_url, formData, {
+                headers: Object.assign(Object.assign({}, formData.getHeaders()), (!fileStream.headers['content-length']
                     ? {
                         'Content-Length': constants_1.MAX_DEVREV_ARTIFACT_SIZE,
                     }
@@ -168,6 +179,26 @@ class Uploader {
             return;
         }
     }
+    async confirmArtifactUpload(artifactId) {
+        const url = `${this.devrevApiEndpoint}/internal/airdrop.artifacts.confirm-upload`;
+        try {
+            const response = await axios_client_1.axiosClient.post(url, {
+                request_id: this.requestId,
+                artifact_id: artifactId,
+            }, {
+                headers: Object.assign({}, this.defaultHeaders),
+            });
+            return response;
+        }
+        catch (error) {
+            if (axios_client_1.axios.isAxiosError(error)) {
+                console.error('Error while confirming artifact upload.', (0, logger_1.serializeAxiosError)(error));
+            }
+            else {
+                console.error('Error while confirming artifact upload.', error);
+            }
+        }
+    }
     async getAttachmentsFromArtifactId({ artifact, }) {
         // Get the URL of the attachments metadata artifact
         const artifactUrl = await this.getArtifactDownloadUrl(artifact);
@@ -200,18 +231,24 @@ class Uploader {
         return { attachments: jsonObject };
     }
     async getArtifactDownloadUrl(artifactId) {
+        const url = `${this.devrevApiEndpoint}/internal/airdrop.artifacts.download-url`;
         try {
-            const response = await axios_client_1.axiosClient.post(`${this.devrevApiEndpoint}/artifacts.locate`, {
-                id: artifactId,
-            }, {
-                headers: {
-                    Authorization: `Bearer ${this.devrevApiToken}`,
+            const response = await axios_client_1.axiosClient.get(url, {
+                headers: Object.assign({}, this.defaultHeaders),
+                params: {
+                    request_id: this.requestId,
+                    artifact_id: artifactId,
                 },
             });
-            return response.data.url;
+            return response.data.download_url;
         }
         catch (error) {
-            console.error('Error while getting artifact download URL.', error);
+            if (axios_client_1.axios.isAxiosError(error)) {
+                console.error('Error while getting artifact download URL.', (0, logger_1.serializeAxiosError)(error));
+            }
+            else {
+                console.error('Error while getting artifact download URL.', error);
+            }
         }
     }
     async downloadArtifact(artifactUrl) {

package/dist/uploader/uploader.test.js

@@ -3,29 +3,89 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const test_helpers_1 = require("../tests/test-helpers");
 const types_1 = require("../types");
 const uploader_1 = require("./uploader");
-// mock uploader.upload method
-jest.mock('./uploader', () => {
-    return {
-        Uploader: jest.fn().mockImplementation(() => {
-            return {
-                upload: jest.fn().mockResolvedValue({
-                    artifact: { key: 'value' },
-                    error: undefined,
-                }),
-            };
-        }),
-    };
+const axios_client_1 = require("../http/axios-client");
+jest.mock('../http/axios-client', () => {
+    const originalModule = jest.requireActual('../http/axios-client');
+    return Object.assign(Object.assign({}, originalModule), { axiosClient: {
+            get: jest.fn(),
+            post: jest.fn(),
+        } });
 });
-describe('uploader.ts', () => {
+const getSuccessResponse = () => ({
+    data: {
+        message: 'Success',
+    },
+    status: 200,
+    statusText: 'OK',
+    headers: {},
+    config: {},
+});
+const getArtifactUploadUrlMockResponse = {
+    data: {
+        artifact_id: 'mockArtifactId',
+        upload_url: 'mockUploadUrl',
+        form_data: [],
+    },
+};
+describe('Uploader Class Tests', () => {
     const mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart });
-    const uploader = new uploader_1.Uploader({ event: mockEvent });
+    let uploader;
+    beforeEach(() => {
+        uploader = new uploader_1.Uploader({ event: mockEvent });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
     it('should upload the file to the DevRev platform and return the artifact information', async () => {
+        // Mock successful response from getArtifactUploadUrl
+        axios_client_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
+        // Mock successful response from confirmArtifactUpload and uploadArtifact
+        axios_client_1.axiosClient.post.mockResolvedValue(getSuccessResponse());
+        const entity = 'entity';
+        const fetchedObjects = [{ key: 'value' }];
+        const uploadResponse = await uploader.upload(entity, fetchedObjects);
+        expect(uploadResponse).toEqual({
+            artifact: {
+                id: 'mockArtifactId',
+                item_type: entity,
+                item_count: fetchedObjects.length,
+            },
+        });
+    });
+    it('should handle failure in getArtifactUploadUrl', async () => {
+        // Mock unsuccessful response for getArtifactUploadUrl
+        axios_client_1.axiosClient.get.mockResolvedValueOnce(undefined);
+        const entity = 'entity';
+        const fetchedObjects = [{ key: 'value' }];
+        const uploadResponse = await uploader.upload(entity, fetchedObjects);
+        expect(uploadResponse).toEqual({
+            error: { message: 'Error while getting artifact upload URL.' },
+        });
+    });
+    it('should handle failure in uploadArtifact', async () => {
+        // Mock successful response for getArtifactUploadUrl
+        axios_client_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
+        // Mock unsuccessful response for uploadArtifact
+        axios_client_1.axiosClient.post.mockResolvedValueOnce(undefined);
+        const entity = 'entity';
+        const fetchedObjects = [{ key: 'value' }];
+        const uploadResponse = await uploader.upload(entity, fetchedObjects);
+        expect(uploadResponse).toEqual({
+            error: { message: 'Error while uploading artifact.' },
+        });
+    });
+    it('should handle failure in confirmArtifactUpload', async () => {
+        // Mock successful response for getArtifactUploadUrl
+        axios_client_1.axiosClient.get.mockResolvedValueOnce(getArtifactUploadUrlMockResponse);
+        // Mock successful response from uploadArtifact
+        axios_client_1.axiosClient.post.mockResolvedValueOnce(getSuccessResponse());
+        // Mock unsuccessful response from confirmArtifactUpload
+        axios_client_1.axiosClient.post.mockResolvedValueOnce(undefined);
         const entity = 'entity';
         const fetchedObjects = [{ key: 'value' }];
         const uploadResponse = await uploader.upload(entity, fetchedObjects);
         expect(uploadResponse).toEqual({
-            artifact: { key: 'value' },
-            error: undefined,
+            error: { message: 'Error while confirming artifact upload.' },
         });
     });
 });

package/dist/workers/worker-adapter.js

@@ -15,6 +15,7 @@ const mappers_1 = require("../mappers/mappers");
 const uploader_1 = require("../uploader/uploader");
 const logger_1 = require("../logger/logger");
 const mappers_interface_1 = require("../mappers/mappers.interface");
+const helpers_2 = require("../common/helpers");
 function createWorkerAdapter({ event, adapterState, options, }) {
     return new WorkerAdapter({
         event,
@@ -91,6 +92,10 @@ class WorkerAdapter {
             }
             // Loop through the batches of attachments
             for (let i = lastProcessedBatchIndex; i < reducedAttachments.length; i++) {
+                // Check if we hit timeout 
+                if (adapter.isTimeout) {
+                    await (0, helpers_2.sleep)(constants_1.DEFAULT_SLEEP_DELAY_MS);
+                }
                 const attachmentsBatch = reducedAttachments[i];
                 // Create a list of promises for parallel processing
                 const promises = [];
@@ -617,19 +622,27 @@ class WorkerAdapter {
         }
         if (httpStream) {
             const fileType = ((_a = httpStream.headers) === null || _a === void 0 ? void 0 : _a['content-type']) || 'application/octet-stream';
-            const preparedArtifact = await this.uploader.prepareArtifact(attachment.file_name, fileType);
+            // Get upload URL
+            const preparedArtifact = await this.uploader.getArtifactUploadUrl(attachment.file_name, fileType);
             if (!preparedArtifact) {
                 console.warn(`Error while preparing artifact for attachment ID ${attachment.id}. Skipping attachment.`);
                 return;
             }
-            const uploadedArtifact = await this.uploader.streamToArtifact(preparedArtifact, httpStream);
+            // Stream attachment
+            const uploadedArtifact = await this.uploader.streamArtifact(preparedArtifact, httpStream);
             if (!uploadedArtifact) {
                 console.warn(`Error while streaming to artifact for attachment ID ${attachment.id}. Skipping attachment.`);
                 return;
             }
+            // Confirm attachment upload
+            const confirmArtifactUploadResponse = await this.uploader.confirmArtifactUpload(preparedArtifact.artifact_id);
+            if (!confirmArtifactUploadResponse) {
+                console.warn('Error while confirming upload for attachment ID ' + attachment.id);
+                return;
+            }
             const ssorAttachment = {
                 id: {
-                    devrev: preparedArtifact.id,
+                    devrev: preparedArtifact.artifact_id,
                     external: attachment.id,
                 },
                 parent_id: {

package/package.json

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