@devrev/ts-adaas 1.3.0 → 1.4.1

package/README.md

@@ -23,275 +23,4 @@ npm install @devrev/ts-adaas
 
 ## Reference
 
-### `spawn` function
-
-This function initializes a new worker thread and oversees its lifecycle. 
-It should be invoked when the snap-in receives a message from the Airdrop platform.
-The worker script provided then handles the event accordingly.
-
-#### Usage
-
-```typescript
-spawn({ event, initialState, workerPath, options })
-```
-
-#### Parameters
-
-* _event_
-  
-  Required. An object of type __AirdropEvent__ that is received from the Airdrop platform.
-
-* _initialState_
-
-  Required. Object of __any__ type that represents the initial state of the snap-in.
-
-* _workerPath_
-
-  Required. A __string__ that represents the path to the worker file.
-
-* _options_
-
-  Optional. An object of type **WorkerAdapterOptions**, which will be passed to the newly created worker. This worker will then initialize a `WorkerAdapter` by invoking the `processTask` function. The options include:
-  
-  * `isLocalDevelopment`
-  
-    A __boolean__ flag. If set to `true`, intermediary files containing extracted data will be stored on the local machine, which is useful during development. The default value is `false`.
-
-  * `timeout`
-  
-    A __number__ that specifies the timeout duration for the lambda function, in milliseconds. The default is 10 minutes (10 * 60 * 1000 milliseconds), with a maximum allowable duration of 13 minutes (13 * 60 * 1000 milliseconds).
-  
-  * `batchSize`
-
-    A __number__ that determines the maximum number of items to be processed and saved to an intermediary file before being sent to the Airdrop platform. The default batch size is 2,000.
-
-#### Return value
-
-A __promise__ that resolves once the worker has completed processing.
-
-#### Example
-
-```typescript
-const run = async (events: AirdropEvent[]) => {
-  for (const event of events) {
-    const file = getWorkerPerExtractionPhase(event);
-    await spawn<ExtractorState>({
-      event,
-      initialState,
-      workerPath: file,
-    });
-  }
-};
-```
-
-### `processTask` function
-
-The `processTask` function retrieves the current state from the Airdrop platform and initializes a new `WorkerAdapter`.
-It executes the code specified in the `task` parameter, which contains the worker's functionality.
-If a timeout occurs, the function handles it by executing the `onTimeout` callback, ensuring the worker exits gracefully.
-Both functions receive an `adapter` parameter, representing the initialized `WorkerAdapter` object.
-
-
-#### Usage
-```typescript
-processTask({ task, onTimeout })
-```
-
-#### Parameters
-
-* _task_
-  
-  Required. A __function__ that defines the logic associated with the given event type.
-
-* _onTimeout_
-  
-  Required. A __function__ managing the timeout of the lambda invocation, including saving any necessary progress at the time of timeout.
-
-#### Example
-
-````typescript
-// External sync units extraction
-processTask({
-  task: async ({ adapter }) => {
-    const httpClient = new HttpClient(adapter.event);
-
-    const todoLists = await httpClient.getTodoLists();
-
-    const externalSyncUnits: ExternalSyncUnit[] = todoLists.map((todoList) => normalizeTodoList(todoList));
-
-    await adapter.emit(ExtractorEventType.ExtractionExternalSyncUnitsDone, {
-      external_sync_units: externalSyncUnits,
-    });
-  },
-  onTimeout: async ({ adapter }) => {
-    await adapter.emit(ExtractorEventType.ExtractionExternalSyncUnitsError, {
-      error: {
-        message: 'Failed to extract external sync units. Lambda timeout.',
-      },
-    });
-  },
-});
-````
-
-### `WorkerAdapter` class
-
-Used to interact with Airdrop platform. 
-Provides utilities to emit events to the Airdrop platform, update the state of the snap-in and upload artifacts (files with data) to the platform.
-
-### Usage
-
-```typescript
-new WorkerAdapter({
-  event,
-  adapterState,
-  options,
-});
-```
-
-#### Parameters
-
-* _event_
-  
-  Required. An object of type __AirdropEvent__ that is received from the Airdrop platform.
-
-* _adapterState_
-  
-  Required. An object of type __State__, which represents the initial state of the adapter.
-
-* _options_
-  
-  Optional. An object of type __WorkerAdapterOptions__ that specifies additional configuration options for the `WorkerAdapter`. This object is passed via the `spawn` function.
-
-#### Example
-
-```typescript
-const adapter = new WorkerAdapter<ConnectorState>({
-  event,
-  adapterState,
-  options,
-});
-```
-
-### `WorkerAdapter.state` property
-
-Getter and setter methods for working with the adapter state.
-
-### Usage
-
-```typescript
-// get state
-const adapterState = adapter.state;
-
-// set state
-adapter.state = newAdapterState;
-```
-
-#### Example
-
-```typescript
-export const initialState: ExtractorState = {
-  users: { completed: false },
-  tasks: { completed: false },
-  attachments: { completed: false },
-};
-
-adapter.state = initialState;
-```
-
-### `WorkerAdapter.initializeRepos` method
-
-Initializes a `Repo` object for each item provided.
-
-### Usage
-
-```typescript
-adapter.initializeRepos(repos);
-```
-
-#### Parameters
-
-* _repos_
-  
-  Required. An array of objects of type `RepoInterface`. 
-
-#### Example
-
-This should typically be called within the function passed as a parameter to the `processTask` function in the data extraction phase.
-
-```typescript
-const repos = [
-  {
-    itemType: 'tasks',
-    normalize: normalizeTask,
-  }
-];
-
-adapter.initializeRepos(repos);
-```
-
-### `WorkerAdapter.getRepo` method
-
-Finds a Repo from the initialized repos.
-
-### Usage
-
-```typescript
-adapter.getRepo(itemType);
-```
-
-#### Parameters
-
-* _itemType_
-  
-  Required. A __string__ that represents the itemType property for the searched repo.
-
-#### Return value
-
-An object of type __Repo__ if the repo is found, otherwise __undefined__.
-
-#### Example
-
-This should typically be called within the function passed as a parameter to the `processTask` function.
-
-```typescript
-// Push users to the repository designated for 'users' data.
-await adapter.getRepo('users')?.push(users);
-```
-
-### `WorkerAdapter.emit` method
-
-Emits an event to the Airdrop platform.
-
-### Usage
-
-```typescript
-adapter.emit( newEventType, data ):
-```
-
-#### Parameters
-
-* _newEventType_
-  
-  Required. The event type to be emitted, of type __ExtractorEventType__ or __LoaderEventType__.
-
-* _data_
-  
-  Optional. An object of type __EventData__ which represents the data to be sent with the event.
-
-#### Return value
-
-A __promise__, which resolves to undefined after the emit function completes its execution or rejects with an error.
-
-#### Example
-
-This should typically be called within the function passed as a parameter to the `processTask` function.
-
-```typescript
-// Emitting successfully finished data extraction.
-await adapter.emit(ExtractorEventType.ExtractionDataDone);
-
-// Emitting a delay in attachments extraction phase.
-await adapter.emit(ExtractorEventType.ExtractionAttachmentsDelay, {
-  delay: 10,
-});
-```
+Please refer to the [REFERENCE.md](./REFERENCE.md) file for more information on the types, interfaces and functions used in the library.

package/dist/repo/repo.d.ts

@@ -11,5 +11,5 @@ export declare class Repo {
     constructor({ event, itemType, normalize, onUpload, options, }: RepoFactoryInterface);
     getItems(): (NormalizedItem | NormalizedAttachment | Item)[];
     upload(batch?: (NormalizedItem | NormalizedAttachment | Item)[]): Promise<void | ErrorRecord>;
-    push(items: Item[]): Promise<boolean | ErrorRecord>;
+    push(items: Item[]): Promise<boolean>;
 }

package/dist/repo/repo.interfaces.d.ts

@@ -36,7 +36,7 @@ export interface NormalizedAttachment {
     file_name: string;
     parent_id: string;
     author_id?: string;
-    grand_parent_id?: number;
+    grand_parent_id?: number | string;
 }
 /**
  * Item is an interface that defines the structure of an item.

package/dist/state/state.interfaces.d.ts

@@ -18,6 +18,7 @@ export interface ToDevRev {
     attachmentsMetadata: {
         artifactIds: string[];
         lastProcessed: number;
+        lastProcessedAttachmentsIdsList?: string[];
     };
 }
 export interface FromDevRev {

package/dist/state/state.js

@@ -62,6 +62,7 @@ class State {
                         attachmentsMetadata: {
                             artifactIds: [],
                             lastProcessed: 0,
+                            lastProcessedAttachmentsIdsList: [],
                         },
                     },
                 };

package/dist/types/extraction.d.ts

@@ -258,9 +258,10 @@ export type StreamAttachmentsReturnType = {
     delay?: number;
     error?: ErrorRecord;
 } | undefined;
-export type ExternalSystemAttachmentReducerFunction<Batch, NewBatch, ConnectorState> = ({ attachments, adapter, }: {
+export type ExternalSystemAttachmentReducerFunction<Batch, NewBatch, ConnectorState> = ({ attachments, adapter, batchSize, }: {
     attachments: Batch;
     adapter: WorkerAdapter<ConnectorState>;
+    batchSize?: number;
 }) => NewBatch;
 export type ExternalProcessAttachmentFunction = ({ attachment, stream, }: {
     attachment: NormalizedAttachment;

package/dist/workers/worker-adapter.d.ts

@@ -24,10 +24,10 @@ export declare function createWorkerAdapter<ConnectorState>({ event, adapterStat
 export declare class WorkerAdapter<ConnectorState> {
     readonly event: AirdropEvent;
     readonly options?: WorkerAdapterOptions;
+    isTimeout: boolean;
     private adapterState;
     private _artifacts;
     private hasWorkerEmitted;
-    private isTimeout;
     private repos;
     private loaderReports;
     private _processedFiles;
@@ -68,6 +68,27 @@ export declare class WorkerAdapter<ConnectorState> {
         item: ExternalSystemAttachment;
         create: ExternalSystemLoadingFunction<ExternalSystemAttachment>;
     }): Promise<LoadItemResponse>;
+    /**
+     * Transforms an array of attachments into array of batches of the specified size.
+     *
+     * @param {Object} parameters - The parameters object
+     * @param {NormalizedAttachment[]} parameters.attachments - Array of attachments to be processed
+     * @param {number} [parameters.batchSize=1] - The size of each batch (defaults to 1)
+     * @param {ConnectorState} parameters.adapter - The adapter instance
+     * @returns {NormalizedAttachment[][]} An array of attachment batches
+     */
+    private defaultAttachmentsReducer;
+    /**
+     * This iterator function processes attachments batch by batch, saves progress to state, and handles rate limiting.
+     *
+     * @param {Object} parameters - The parameters object
+     * @param {NormalizedAttachment[][]} parameters.reducedAttachments - Array of attachment batches to process
+     * @param {Object} parameters.adapter - The connector adapter that contains state and processing methods
+     * @param {Object} parameters.stream - Stream object for logging or progress reporting
+     * @returns {Promise<{delay?: number} | void>} Returns an object with delay information if rate-limited, otherwise void
+     * @throws Will not throw exceptions but will log warnings for processing failures
+     */
+    private defaultAttachmentsIterator;
     /**
      * Streams the attachments to the DevRev platform.
      * The attachments are streamed to the platform and the artifact information is returned.
@@ -75,8 +96,9 @@ export declare class WorkerAdapter<ConnectorState> {
      * @returns {Promise<StreamAttachmentsReturnType>} - The response object containing the ssorAttachment artifact information
      * or error information if there was an error
      */
-    streamAttachments<NewBatch>({ stream, processors, }: {
+    streamAttachments<NewBatch>({ stream, processors, batchSize, }: {
         stream: ExternalSystemAttachmentStreamingFunction;
         processors?: ExternalSystemAttachmentProcessors<ConnectorState, NormalizedAttachment[], NewBatch>;
+        batchSize?: number;
     }): Promise<StreamAttachmentsReturnType>;
 }

package/dist/workers/worker-adapter.js

@@ -39,6 +39,104 @@ function createWorkerAdapter({ event, adapterState, options, }) {
 class WorkerAdapter {
     constructor({ event, adapterState, options, }) {
         this.repos = [];
+        /**
+         * Transforms an array of attachments into array of batches of the specified size.
+         *
+         * @param {Object} parameters - The parameters object
+         * @param {NormalizedAttachment[]} parameters.attachments - Array of attachments to be processed
+         * @param {number} [parameters.batchSize=1] - The size of each batch (defaults to 1)
+         * @param {ConnectorState} parameters.adapter - The adapter instance
+         * @returns {NormalizedAttachment[][]} An array of attachment batches
+         */
+        this.defaultAttachmentsReducer = ({ attachments, batchSize = 1 }) => {
+            // Transform the attachments array into smaller batches
+            const batches = attachments.reduce((result, item, index) => {
+                // Determine the index of the current batch
+                const batchIndex = Math.floor(index / batchSize);
+                // Initialize a new batch if it doesn't already exist
+                if (!result[batchIndex]) {
+                    result[batchIndex] = [];
+                }
+                // Append the current item to the current batch
+                result[batchIndex].push(item);
+                return result;
+            }, []);
+            // Return the array of batches
+            return batches;
+        };
+        /**
+         * This iterator function processes attachments batch by batch, saves progress to state, and handles rate limiting.
+         *
+         * @param {Object} parameters - The parameters object
+         * @param {NormalizedAttachment[][]} parameters.reducedAttachments - Array of attachment batches to process
+         * @param {Object} parameters.adapter - The connector adapter that contains state and processing methods
+         * @param {Object} parameters.stream - Stream object for logging or progress reporting
+         * @returns {Promise<{delay?: number} | void>} Returns an object with delay information if rate-limited, otherwise void
+         * @throws Will not throw exceptions but will log warnings for processing failures
+         */
+        this.defaultAttachmentsIterator = async ({ reducedAttachments, adapter, stream }) => {
+            if (!adapter.state.toDevRev) {
+                const error = new Error(`toDevRev state is not defined.`);
+                console.error(error.message);
+                return { error };
+            }
+            // Get index of the last processed batch of this artifact
+            const lastProcessedBatchIndex = adapter.state.toDevRev.attachmentsMetadata.lastProcessed || 0;
+            // Get the list of successfully processed attachments in previous (possibly incomplete) batch extraction.
+            // If no such list exists, create an empty one.
+            if (!adapter.state.toDevRev.attachmentsMetadata
+                .lastProcessedAttachmentsIdsList) {
+                adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
+                    [];
+            }
+            // Loop through the batches of attachments
+            for (let i = lastProcessedBatchIndex; i < reducedAttachments.length; i++) {
+                const attachmentsBatch = reducedAttachments[i];
+                // Create a list of promises for parallel processing
+                const promises = [];
+                for (const attachment of attachmentsBatch) {
+                    if (adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList.includes(attachment.id)) {
+                        console.log(`Attachment with ID ${attachment.id} has already been processed. Skipping.`);
+                        continue; // Skip if the attachment ID is already processed
+                    }
+                    const promise = adapter
+                        .processAttachment(attachment, stream)
+                        .then((response) => {
+                        var _a, _b, _c;
+                        // Check if rate limit was hit
+                        if (response === null || response === void 0 ? void 0 : response.delay) {
+                            // Store this promise result to be checked later
+                            return { delay: response.delay };
+                        }
+                        // No rate limiting, process normally
+                        if ((_b = (_a = adapter.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata) === null || _b === void 0 ? void 0 : _b.lastProcessedAttachmentsIdsList) {
+                            (_c = adapter.state.toDevRev) === null || _c === void 0 ? void 0 : _c.attachmentsMetadata.lastProcessedAttachmentsIdsList.push(attachment.id);
+                        }
+                        return null; // Return null for successful processing
+                    })
+                        .catch((error) => {
+                        console.warn(`Skipping attachment with ID ${attachment.id} due to error: ${error}`);
+                        return null; // Return null for errors too
+                    });
+                    promises.push(promise);
+                }
+                // Wait for all promises to settle and check for rate limiting
+                const results = await Promise.all(promises);
+                // Check if any of the results indicate rate limiting
+                const rateLimit = results.find((result) => result === null || result === void 0 ? void 0 : result.delay);
+                if (rateLimit) {
+                    // Return the delay information to the caller
+                    return { delay: rateLimit.delay };
+                }
+                if (adapter.state.toDevRev) {
+                    // Update the last processed batch index
+                    adapter.state.toDevRev.attachmentsMetadata.lastProcessed = i + 1;
+                    // Reset successfullyProcessedAttachments list
+                    adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList.length = 0;
+                }
+            }
+            return {};
+        };
         this.event = event;
         this.options = options;
         this.adapterState = adapterState;
@@ -88,7 +186,7 @@ class WorkerAdapter {
     getRepo(itemType) {
         const repo = this.repos.find((repo) => repo.itemType === itemType);
         if (!repo) {
-            console.error(`Repo not found for item type: ${itemType}.`);
+            console.error(`Repo for item type ${itemType} not found.`);
             return;
         }
         return repo;
@@ -586,14 +684,21 @@ class WorkerAdapter {
      * @returns {Promise<StreamAttachmentsReturnType>} - The response object containing the ssorAttachment artifact information
      * or error information if there was an error
      */
-    async streamAttachments({ stream, processors, }) {
+    async streamAttachments({ stream, processors, batchSize = 1, // By default, we want to stream one attachment at a time
+     }) {
         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 };
+        }
         const repos = [
             {
                 itemType: 'ssor_attachment',
             },
         ];
         this.initializeRepos(repos);
+        // If there are no attachments metadata artifact IDs in state, finish here
         if (!((_b = (_a = this.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata) === null || _b === void 0 ? void 0 : _b.artifactIds) ||
             this.state.toDevRev.attachmentsMetadata.artifactIds.length === 0) {
             console.log(`No attachments metadata artifact IDs found in state.`);
@@ -602,6 +707,7 @@ class WorkerAdapter {
         else {
             console.log(`Found ${this.state.toDevRev.attachmentsMetadata.artifactIds.length} attachments metadata artifact IDs in state.`);
         }
+        // Loop through the attachments metadata artifact IDs
         while (this.state.toDevRev.attachmentsMetadata.artifactIds.length > 0) {
             const attachmentsMetadataArtifactId = this.state.toDevRev.attachmentsMetadata.artifactIds[0];
             console.log(`Started processing attachments for attachments metadata artifact ID: ${attachmentsMetadataArtifactId}.`);
@@ -620,35 +726,34 @@ class WorkerAdapter {
                 continue;
             }
             console.log(`Found ${attachments.length} attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
+            // Use the reducer to split into batches.
+            let reducer;
+            // Use the iterator to process each batch, streaming all attachments inside one batch in parallel.
+            let iterator;
             if (processors) {
                 console.log(`Using custom processors for attachments.`);
-                const { reducer, iterator } = processors;
-                const reducedAttachments = reducer({ attachments, adapter: this });
-                const response = await iterator({
-                    reducedAttachments,
-                    adapter: this,
-                    stream,
-                });
-                if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
-                    return response;
-                }
+                reducer = processors.reducer;
+                iterator = processors.iterator;
             }
             else {
                 console.log(`Using default processors for attachments.`);
-                const startIndex = this.state.toDevRev.attachmentsMetadata.lastProcessed || 0;
-                const attachmentsToProcess = attachments.slice(startIndex);
-                for (const attachment of attachmentsToProcess) {
-                    const response = await this.processAttachment(attachment, stream);
-                    if (response === null || response === void 0 ? void 0 : response.delay) {
-                        return response;
-                    }
-                    else if (response === null || response === void 0 ? void 0 : response.error) {
-                        console.warn('Skipping attachment due to an error while processing', attachment);
-                    }
-                    if (this.state.toDevRev) {
-                        this.state.toDevRev.attachmentsMetadata.lastProcessed += 1;
-                    }
-                }
+                reducer = this
+                    .defaultAttachmentsReducer;
+                iterator = this
+                    .defaultAttachmentsIterator;
+            }
+            const reducedAttachments = reducer({
+                attachments,
+                adapter: this,
+                batchSize,
+            });
+            const response = await iterator({
+                reducedAttachments,
+                adapter: this,
+                stream,
+            });
+            if ((response === null || response === void 0 ? void 0 : response.delay) || (response === null || response === void 0 ? void 0 : response.error)) {
+                return response;
             }
             console.log(`Finished processing all attachments for artifact ID: ${attachmentsMetadataArtifactId}.`);
             this.state.toDevRev.attachmentsMetadata.artifactIds.shift();

package/dist/workers/worker-adapter.test.d.ts

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

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

@@ -0,0 +1,664 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_adapter_1 = require("./worker-adapter");
+const state_1 = require("../state/state");
+const test_helpers_1 = require("../tests/test-helpers");
+const types_1 = require("../types");
+// Mock dependencies
+jest.mock('../common/control-protocol', () => ({
+    emit: jest.fn().mockResolvedValue({}),
+}));
+// const mockPostState = jest.spyOn(State.prototype, 'postState').mockResolvedValue(); // Mock to resolve void
+// const mockFetchState = jest.spyOn(State.prototype, 'fetchState').mockResolvedValue({}); // Mock to resolve a default state
+jest.mock('../mappers/mappers');
+jest.mock('../uploader/uploader');
+// jest.mock('../state/state');
+jest.mock('../repo/repo');
+jest.mock('node:worker_threads', () => ({
+    parentPort: {
+        postMessage: jest.fn(),
+    },
+}));
+describe('WorkerAdapter', () => {
+    let adapter;
+    let mockEvent;
+    let mockAdapterState;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Create mock objects
+        mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart });
+        const initialState = {
+            attachments: { completed: false },
+            lastSyncStarted: '',
+            lastSuccessfulSyncStarted: '',
+            snapInVersionId: '',
+            toDevRev: {
+                attachmentsMetadata: {
+                    artifactIds: [],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            },
+        };
+        mockAdapterState = new state_1.State({
+            event: mockEvent,
+            initialState: initialState,
+        });
+        // Create the adapter instance
+        adapter = new worker_adapter_1.WorkerAdapter({
+            event: mockEvent,
+            adapterState: mockAdapterState,
+        });
+    });
+    describe('defaultAttachmentsReducer', () => {
+        it('should correctly batch attachments based on the batchSize', () => {
+            // Arrange
+            const attachments = [
+                { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                { url: 'http://example.com/file3.pdf', id: 'attachment3', file_name: 'file3.pdf', parent_id: 'parent3' },
+                { url: 'http://example.com/file4.pdf', id: 'attachment4', file_name: 'file4.pdf', parent_id: 'parent4' },
+                { url: 'http://example.com/file5.pdf', id: 'attachment5', file_name: 'file5.pdf', parent_id: 'parent5' },
+            ];
+            // Act - call the private method using function call notation
+            const result = adapter['defaultAttachmentsReducer']({
+                attachments,
+                adapter,
+                batchSize: 2,
+            });
+            // Assert
+            expect(result).toHaveLength(3);
+            expect(result[0]).toHaveLength(2);
+            expect(result[1]).toHaveLength(2);
+            expect(result[2]).toHaveLength(1);
+            expect(result[0][0].id).toBe('attachment1');
+            expect(result[0][1].id).toBe('attachment2');
+            expect(result[1][0].id).toBe('attachment3');
+            expect(result[1][1].id).toBe('attachment4');
+            expect(result[2][0].id).toBe('attachment5');
+        });
+        it('should return a single batch when batchSize equals the number of attachments', () => {
+            // Arrange
+            const attachments = [
+                { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+            ];
+            // Act
+            const result = adapter['defaultAttachmentsReducer']({
+                attachments,
+                adapter,
+                batchSize: 2,
+            });
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveLength(2);
+            expect(result[0][0].id).toBe('attachment1');
+            expect(result[0][1].id).toBe('attachment2');
+        });
+        it('should return a single batch when batchSize is bigger than the number of attachments', () => {
+            // Arrange
+            const attachments = [
+                { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+            ];
+            // Act
+            const result = adapter['defaultAttachmentsReducer']({
+                attachments,
+                adapter,
+                batchSize: 10,
+            });
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveLength(2);
+            expect(result[0][0].id).toBe('attachment1');
+            expect(result[0][1].id).toBe('attachment2');
+        });
+        it('should handle empty attachments array', () => {
+            // Arrange
+            const attachments = [];
+            // Act
+            const result = adapter['defaultAttachmentsReducer']({
+                attachments,
+                adapter,
+                batchSize: 2,
+            });
+            // Assert
+            expect(result).toHaveLength(0);
+        });
+        it('should default to batchSize of 1 if not provided', () => {
+            // Arrange
+            const attachments = [
+                { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+            ];
+            // Act
+            const result = adapter['defaultAttachmentsReducer']({
+                attachments,
+                adapter
+            });
+            // Assert
+            expect(result).toHaveLength(2);
+            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 () => {
+            var _a, _b;
+            // Arrange
+            const mockAttachments = [
+                [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                ],
+                [
+                    { url: 'http://example.com/file3.pdf', id: 'attachment3', file_name: 'file3.pdf', parent_id: 'parent3' },
+                ],
+            ];
+            const mockStream = jest.fn();
+            // Mock the processAttachment method 
+            adapter.processAttachment = jest.fn().mockResolvedValue(null);
+            // Act
+            const result = await adapter['defaultAttachmentsIterator']({
+                reducedAttachments: mockAttachments,
+                adapter: adapter,
+                stream: mockStream,
+            });
+            // Assert
+            expect(adapter.processAttachment).toHaveBeenCalledTimes(3);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0][0], mockStream);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0][1], mockStream);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[1][0], mockStream);
+            // Verify the state was updated correctly
+            expect((_a = adapter.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata.lastProcessed).toBe(2);
+            expect((_b = adapter.state.toDevRev) === null || _b === void 0 ? void 0 : _b.attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([]);
+            expect(result).toEqual({});
+        });
+        it('should handle rate limiting during processing', async () => {
+            var _a;
+            // Arrange
+            const mockAttachments = [
+                [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                ],
+                [
+                    { url: 'http://example.com/file3.pdf', id: 'attachment3', file_name: 'file3.pdf', parent_id: 'parent3' },
+                ],
+            ];
+            const mockStream = jest.fn();
+            // Mock the processAttachment method to simulate rate limiting on the second attachment
+            adapter.processAttachment = jest.fn()
+                .mockResolvedValueOnce(null) // First attachment processes successfully
+                .mockResolvedValueOnce({ delay: 30 }); // Second attachment hits rate limit
+            // Set up adapter state
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    lastProcessed: 0,
+                    artifactIds: [],
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Act
+            const result = await adapter['defaultAttachmentsIterator']({
+                reducedAttachments: mockAttachments,
+                adapter: adapter,
+                stream: mockStream,
+            });
+            // Assert
+            expect(adapter.processAttachment).toHaveBeenCalledTimes(2);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0][0], mockStream);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0][1], mockStream);
+            // Verify the delay was returned
+            expect(result).toEqual({ delay: 30 });
+            // And lastProcessed wasn't updated yet
+            expect((_a = adapter.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata.lastProcessed).toBe(0);
+        });
+        it('should skip already processed attachments', async () => {
+            // Arrange
+            const mockAttachments = [
+                [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                ],
+            ];
+            const mockStream = jest.fn();
+            // Mock the processAttachment method
+            adapter.processAttachment = jest.fn().mockResolvedValue(null);
+            // Set up adapter state to indicate attachment1 was already processed
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    lastProcessed: 0,
+                    artifactIds: [],
+                    lastProcessedAttachmentsIdsList: ['attachment1'],
+                },
+            };
+            // Act
+            await adapter['defaultAttachmentsIterator']({
+                reducedAttachments: mockAttachments,
+                adapter: adapter,
+                stream: mockStream,
+            });
+            // Assert
+            expect(adapter.processAttachment).toHaveBeenCalledTimes(1);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[0][1], mockStream);
+            expect(adapter.processAttachment).not.toHaveBeenCalledWith(mockAttachments[0][0], mockStream);
+        });
+        it('should continue from last processed batch', async () => {
+            // Arrange
+            const mockAttachments = [
+                [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                ],
+                [
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                ],
+            ];
+            const mockStream = jest.fn();
+            // Mock the processAttachment method
+            adapter.processAttachment = jest.fn().mockResolvedValue(null);
+            // Set up adapter state to indicate we already processed the first batch
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    lastProcessed: 1, // Skip first batch (index 0)
+                    artifactIds: [],
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Act
+            await adapter['defaultAttachmentsIterator']({
+                reducedAttachments: mockAttachments,
+                adapter: adapter,
+                stream: mockStream,
+            });
+            // Assert
+            expect(adapter.processAttachment).toHaveBeenCalledTimes(1);
+            expect(adapter.processAttachment).toHaveBeenCalledWith(mockAttachments[1][0], mockStream);
+            expect(adapter.processAttachment).not.toHaveBeenCalledWith(mockAttachments[0][0], mockStream);
+        });
+        it('should handle errors during processing and continue', async () => {
+            // Arrange
+            const mockAttachments = [
+                [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                ],
+            ];
+            const mockStream = jest.fn();
+            // Mock processAttachment to throw an error for the first attachment
+            adapter.processAttachment = jest.fn()
+                .mockRejectedValueOnce(new Error('Processing error'))
+                .mockResolvedValueOnce(null);
+            // Mock console.warn to avoid test output noise
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            // Set up adapter state
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    lastProcessed: 0,
+                    artifactIds: [],
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Act
+            const result = await adapter['defaultAttachmentsIterator']({
+                reducedAttachments: mockAttachments,
+                adapter: adapter,
+                stream: mockStream,
+            });
+            // Assert - both attachments should have been processed
+            expect(adapter.processAttachment).toHaveBeenCalledTimes(2);
+            expect(consoleWarnSpy).toHaveBeenCalled();
+            expect(result).toEqual({});
+            // Restore console.warn
+            consoleWarnSpy.mockRestore();
+        });
+    });
+    describe('streamAttachments', () => {
+        it('should process all artifact batches successfully', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1', 'artifact2'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments from each artifact
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn()
+                .mockResolvedValueOnce({
+                attachments: [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                ],
+            })
+                .mockResolvedValueOnce({
+                attachments: [
+                    { url: 'http://example.com/file3.pdf', id: 'attachment3', file_name: 'file3.pdf', parent_id: 'parent3' },
+                ],
+            });
+            // Mock the initializeRepos method
+            adapter.initializeRepos = jest.fn();
+            // Mock the defaultAttachmentsReducer and defaultAttachmentsIterator
+            const mockReducedAttachments = [['batch1']];
+            adapter['defaultAttachmentsReducer'] = jest.fn().mockReturnValue(mockReducedAttachments);
+            adapter['defaultAttachmentsIterator'] = jest.fn().mockResolvedValue({});
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            // Assert
+            expect(adapter.initializeRepos).toHaveBeenCalledWith([
+                { itemType: 'ssor_attachment' },
+            ]);
+            expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(2);
+            expect(adapter['defaultAttachmentsReducer']).toHaveBeenCalledTimes(2);
+            expect(adapter['defaultAttachmentsIterator']).toHaveBeenCalledTimes(2);
+            // Verify state was updated correctly
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
+            expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
+            expect(result).toBeUndefined();
+        });
+        it('should handle invalid 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 empty attachments metadata artifact IDs', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            // Set up adapter state with no artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: [],
+                    lastProcessed: 0,
+                },
+            };
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            // Assert
+            expect(consoleLogSpy).toHaveBeenCalledWith('No attachments metadata artifact IDs found in state.');
+            expect(result).toBeUndefined();
+            // Restore console.log
+            consoleLogSpy.mockRestore();
+        });
+        it('should handle errors when getting attachments', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock error when getting attachments
+            const mockError = new Error('Failed to get attachments');
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
+                error: mockError,
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            // Assert
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            expect(result).toEqual({
+                error: mockError,
+            });
+            // Restore console.error
+            consoleErrorSpy.mockRestore();
+        });
+        it('should handle empty attachments array from artifact', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting empty attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
+                attachments: [],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            // Assert
+            expect(consoleWarnSpy).toHaveBeenCalled();
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
+            expect(result).toBeUndefined();
+            // Restore console.warn
+            consoleWarnSpy.mockRestore();
+        });
+        it('should use custom processors when provided', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            const mockReducer = jest.fn().mockReturnValue(['custom-reduced']);
+            const mockIterator = jest.fn().mockResolvedValue({});
+            // 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: [{ id: 'attachment1' }],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+                processors: {
+                    reducer: mockReducer,
+                    iterator: mockIterator,
+                },
+            });
+            // Assert
+            expect(mockReducer).toHaveBeenCalledWith({
+                attachments: [{ id: 'attachment1' }],
+                adapter: adapter,
+                batchSize: 1,
+            });
+            expect(mockIterator).toHaveBeenCalledWith({
+                reducedAttachments: ['custom-reduced'],
+                adapter: adapter,
+                stream: mockStream,
+            });
+            expect(result).toBeUndefined();
+            // Restore console.log
+            consoleLogSpy.mockRestore();
+        });
+        it('should handle rate limiting from iterator', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            // 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: [{ id: 'attachment1' }],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            adapter['defaultAttachmentsReducer'] = jest.fn().mockReturnValue([]);
+            adapter['defaultAttachmentsIterator'] = jest.fn().mockResolvedValue({
+                delay: 30,
+            });
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            // Assert
+            expect(result).toEqual({
+                delay: 30,
+            });
+            // The artifactIds array should remain unchanged
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual(['artifact1']);
+        });
+        it('should handle error from iterator', async () => {
+            // Arrange
+            const mockStream = jest.fn();
+            // 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: [{ id: 'attachment1' }],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            adapter['defaultAttachmentsReducer'] = jest.fn().mockReturnValue([]);
+            const mockError = new Error('Iterator error');
+            adapter['defaultAttachmentsIterator'] = jest.fn().mockResolvedValue({
+                error: mockError,
+            });
+            // Act
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            // Assert
+            expect(result).toEqual({
+                error: mockError,
+            });
+            // The artifactIds array should remain unchanged
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual(['artifact1']);
+        });
+        it('should continue processing from last processed attachment for the current artifact', async () => {
+            const mockStream = jest.fn();
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: ['attachment1', 'attachment2'],
+                },
+            };
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn().mockResolvedValue({
+                attachments: [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                    { url: 'http://example.com/file3.pdf', id: 'attachment3', file_name: 'file3.pdf', parent_id: 'parent3' },
+                ],
+            });
+            adapter.processAttachment = jest.fn().mockResolvedValue(null);
+            await adapter.streamAttachments({
+                stream: mockStream,
+                batchSize: 3,
+            });
+            expect(adapter.processAttachment).toHaveBeenCalledTimes(1);
+            expect(adapter.processAttachment).toHaveBeenCalledWith({
+                url: 'http://example.com/file3.pdf',
+                id: 'attachment3',
+                file_name: 'file3.pdf',
+                parent_id: 'parent3'
+            }, mockStream);
+        });
+        it('should reset lastProcessed and attachment IDs list after processing all artifacts', async () => {
+            const mockStream = jest.fn();
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            adapter['uploader'].getAttachmentsFromArtifactId = jest.fn()
+                .mockResolvedValueOnce({
+                attachments: [
+                    { url: 'http://example.com/file1.pdf', id: 'attachment1', file_name: 'file1.pdf', parent_id: 'parent1' },
+                    { url: 'http://example.com/file2.pdf', id: 'attachment2', file_name: 'file2.pdf', parent_id: 'parent2' },
+                    { url: 'http://example.com/file3.pdf', id: 'attachment3', file_name: 'file3.pdf', parent_id: 'parent3' },
+                ],
+            });
+            adapter.processAttachment = jest.fn().mockResolvedValue(null);
+            await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toHaveLength(0);
+            expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.3.0",
-  "description": "DevRev ADaaS (AirDrop-as-a-Service) Typescript SDK.",
+  "version": "1.4.1",
+  "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -23,22 +23,22 @@
   "author": "devrev",
   "license": "ISC",
   "devDependencies": {
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^29.5.14",
     "@types/lambda-log": "^3.0.3",
-    "@types/node": "20.16.11",
+    "@types/node": "^22.15.18",
     "@types/yargs": "^17.0.33",
-    "@typescript-eslint/eslint-plugin": "^7.12.0",
-    "@typescript-eslint/parser": "^7.12.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "eslint": "^9.26.0",
+    "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-prettier": "^5.1.3",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
+    "ts-jest": "^29.3.3",
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "@devrev/typescript-sdk": "^1.1.54",
-    "axios": "^1.7.9",
+    "@devrev/typescript-sdk": "^1.1.59",
+    "axios": "^1.9.0",
     "axios-retry": "^4.5.0",
     "form-data": "^4.0.1",
     "js-jsonl": "^1.1.1",