@devrev/ts-adaas 1.4.1 → 1.5.0

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/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

@@ -617,19 +617,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: {
@@ -688,9 +696,12 @@ class WorkerAdapter {
      }) {
         var _a, _b;
         if (batchSize <= 0) {
-            const error = new Error(`Invalid attachments batch size: ${batchSize}. Batch size must be greater than 0.`);
-            console.error(error.message);
-            return { error };
+            console.warn(`The specified batch size (${batchSize}) is invalid. Using 1 instead.`);
+            batchSize = 1;
+        }
+        if (batchSize > 50) {
+            console.warn(`The specified batch size (${batchSize}) is too large. Using 50 instead.`);
+            batchSize = 50;
         }
         const repos = [
             {

package/dist/workers/worker-adapter.test.js

@@ -142,44 +142,6 @@ describe('WorkerAdapter', () => {
             expect(result[0]).toHaveLength(1);
             expect(result[1]).toHaveLength(1);
         });
-        it('should handle invalid (0) batch size', async () => {
-            var _a;
-            // Arrange
-            const mockStream = jest.fn();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            // Act
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-                batchSize: 0,
-            });
-            // Assert
-            expect(consoleErrorSpy).toHaveBeenCalled();
-            expect(result).toEqual({
-                error: expect.any(Error),
-            });
-            expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('Invalid attachments batch size');
-            // Restore console.error
-            consoleErrorSpy.mockRestore();
-        });
-        it('should handle invalid (negative) batch size', async () => {
-            var _a;
-            // Arrange
-            const mockStream = jest.fn();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            // Act
-            const result = await adapter.streamAttachments({
-                stream: mockStream,
-                batchSize: -1,
-            });
-            // Assert
-            expect(consoleErrorSpy).toHaveBeenCalled();
-            expect(result).toEqual({
-                error: expect.any(Error),
-            });
-            expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('Invalid attachments batch size');
-            // Restore console.error
-            consoleErrorSpy.mockRestore();
-        });
     });
     describe('defaultAttachmentsIterator', () => {
         it('should process all batches of attachments', async () => {
@@ -400,23 +362,84 @@ describe('WorkerAdapter', () => {
             expect(result).toBeUndefined();
         });
         it('should handle invalid batch size', async () => {
-            var _a;
             // Arrange
             const mockStream = jest.fn();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
+                attachments: [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                ],
+            });
+            // Mock the required methods
+            adapter.initializeRepos = jest.fn();
+            const mockReducedAttachments = [['batch1']];
+            adapter['defaultAttachmentsReducer'] = jest.fn().mockReturnValue(mockReducedAttachments);
+            adapter['defaultAttachmentsIterator'] = jest.fn().mockResolvedValue({});
             // Act
             const result = await adapter.streamAttachments({
                 stream: mockStream,
                 batchSize: 0,
             });
             // Assert
-            expect(consoleErrorSpy).toHaveBeenCalled();
-            expect(result).toEqual({
-                error: expect.any(Error),
+            expect(consoleWarnSpy).toHaveBeenCalledWith('The specified batch size (0) is invalid. Using 1 instead.');
+            // Verify that the reducer was called with batchSize 50 (not 100)
+            expect(adapter['defaultAttachmentsReducer']).toHaveBeenCalledWith({
+                attachments: expect.any(Array),
+                adapter: adapter,
+                batchSize: 1,
             });
-            expect((_a = result === null || result === void 0 ? void 0 : result.error) === null || _a === void 0 ? void 0 : _a.message).toContain('Invalid attachments batch size');
-            // Restore console.error
-            consoleErrorSpy.mockRestore();
+            expect(result).toBeUndefined();
+            // Restore console.warn
+            consoleWarnSpy.mockRestore();
+        });
+        it('should cap batch size to 50 when batchSize is greater than 50', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
+                attachments: [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                ],
+            });
+            // Mock the required methods
+            adapter.initializeRepos = jest.fn();
+            const mockReducedAttachments = [['batch1']];
+            adapter['defaultAttachmentsReducer'] = jest.fn().mockReturnValue(mockReducedAttachments);
+            adapter['defaultAttachmentsIterator'] = jest.fn().mockResolvedValue({});
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+                batchSize: 100, // Set batch size greater than 50
+            });
+            // Assert
+            expect(consoleWarnSpy).toHaveBeenCalledWith('The specified batch size (100) is too large. Using 50 instead.');
+            // Verify that the reducer was called with batchSize 50 (not 100)
+            expect(adapter['defaultAttachmentsReducer']).toHaveBeenCalledWith({
+                attachments: expect.any(Array),
+                adapter: adapter,
+                batchSize: 50, // Should be capped at 50
+            });
+            expect(result).toBeUndefined();
+            // Restore console.warn
+            consoleWarnSpy.mockRestore();
         });
         it('should handle empty attachments metadata artifact IDs', async () => {
             // Arrange

package/package.json

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