@devrev/airsync-sdk 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/attachments-streaming/attachments-streaming-pool.d.ts

@@ -10,6 +10,13 @@ export declare class AttachmentsStreamingPool<ConnectorState> {
     private readonly PROGRESS_REPORT_INTERVAL;
     constructor({ adapter, attachments, batchSize, stream, }: AttachmentsStreamingPoolParams<ConnectorState>);
     private updateProgress;
+    /**
+     * Migrates processed attachments from the legacy string[] format to the new ProcessedAttachment[] format.
+     *
+     * @param attachments - The attachments list to migrate (either string[] or ProcessedAttachment[])
+     * @returns Migrated array of ProcessedAttachment objects, or empty array if input is invalid
+     */
+    private migrateProcessedAttachments;
     streamAll(): Promise<ProcessAttachmentReturnType>;
     startPoolStreaming(): Promise<void>;
 }

package/dist/attachments-streaming/attachments-streaming-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attachments-streaming-pool.d.ts","sourceRoot":"","sources":["../../src/attachments-streaming/attachments-streaming-pool.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,2BAA2B,EAC5B,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAEzF,qBAAa,wBAAwB,CAAC,cAAc;IAClD,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,MAAM,CAA4C;IAE1D,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAM;gBAEnC,EACV,OAAO,EACP,WAAW,EACX,SAAc,EACd,MAAM,GACP,EAAE,8BAA8B,CAAC,cAAc,CAAC;YAQnC,cAAc;IAStB,SAAS,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAuCjD,kBAAkB;CA0EzB"}
+{"version":3,"file":"attachments-streaming-pool.d.ts","sourceRoot":"","sources":["../../src/attachments-streaming/attachments-streaming-pool.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,2BAA2B,EAC5B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAEzF,qBAAa,wBAAwB,CAAC,cAAc;IAClD,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,MAAM,CAA4C;IAE1D,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAM;gBAEnC,EACV,OAAO,EACP,WAAW,EACX,SAAc,EACd,MAAM,GACP,EAAE,8BAA8B,CAAC,cAAc,CAAC;YAQnC,cAAc;IAS5B;;;;;OAKG;IAEH,OAAO,CAAC,2BAA2B;IAsB7B,SAAS,IAAI,OAAO,CAAC,2BAA2B,CAAC;IA8CjD,kBAAkB;CA0FzB"}

package/dist/attachments-streaming/attachments-streaming-pool.js

@@ -20,6 +20,31 @@ class AttachmentsStreamingPool {
             await (0, helpers_1.sleep)(100);
         }
     }
+    /**
+     * Migrates processed attachments from the legacy string[] format to the new ProcessedAttachment[] format.
+     *
+     * @param attachments - The attachments list to migrate (either string[] or ProcessedAttachment[])
+     * @returns Migrated array of ProcessedAttachment objects, or empty array if input is invalid
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    migrateProcessedAttachments(attachments) {
+        // Handle null/undefined
+        if (!attachments || !Array.isArray(attachments)) {
+            return [];
+        }
+        // If already migrated (first element is an object), return as-is
+        if (attachments.length > 0 && typeof attachments[0] === 'object') {
+            return attachments;
+        }
+        // Migrate old string[] format
+        if (attachments.length > 0 && typeof attachments[0] === 'string') {
+            return attachments.map((it) => ({
+                id: it,
+                parent_id: '',
+            }));
+        }
+        return [];
+    }
     async streamAll() {
         console.log(`Starting download of ${this.attachments.length} attachments, streaming ${this.batchSize} at once.`);
         if (!this.adapter.state.toDevRev) {
@@ -34,6 +59,10 @@ class AttachmentsStreamingPool {
             this.adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
                 [];
         }
+        // Migrate old processed attachments to the new format.
+        this.adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
+            this.migrateProcessedAttachments(this.adapter.state.toDevRev.attachmentsMetadata
+                .lastProcessedAttachmentsIdsList);
         // Start initial batch of promises up to batchSize limit
         const initialBatchSize = Math.min(this.batchSize, this.attachments.length);
         const initialPromises = [];
@@ -66,7 +95,7 @@ class AttachmentsStreamingPool {
                 break; // Exit if no more attachments
             }
             if (this.adapter.state.toDevRev &&
-                ((_a = this.adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList) === null || _a === void 0 ? void 0 : _a.includes(attachment.id))) {
+                ((_a = this.adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList) === null || _a === void 0 ? void 0 : _a.some((it) => it.id == attachment.id && it.parent_id == attachment.parent_id))) {
                 continue; // Skip if the attachment ID is already processed
             }
             try {
@@ -77,18 +106,29 @@ class AttachmentsStreamingPool {
                     return;
                 }
                 if (response === null || response === void 0 ? void 0 : response.error) {
-                    console.warn(`Skipping attachment with ID ${attachment.id} due to error returned by the stream function`, response.error);
+                    const fileExtension = attachment.file_name.split('.').pop() || '';
+                    const fileSizeInfo = response.error.fileSize
+                        ? `and size ${response.error.fileSize} bytes `
+                        : '';
+                    const contentTypeInfo = attachment.content_type
+                        ? `and content_type ${attachment.content_type} `
+                        : '';
+                    console.warn(`Skipping attachment with ID ${attachment.id} with extension ${fileExtension} ${fileSizeInfo}${contentTypeInfo}due to error returned by the stream function`, response.error.message);
                     await this.updateProgress();
                     continue;
                 }
                 // No rate limiting, process normally
                 if ((_c = (_b = this.adapter.state.toDevRev) === null || _b === void 0 ? void 0 : _b.attachmentsMetadata) === null || _c === void 0 ? void 0 : _c.lastProcessedAttachmentsIdsList) {
-                    (_d = this.adapter.state.toDevRev) === null || _d === void 0 ? void 0 : _d.attachmentsMetadata.lastProcessedAttachmentsIdsList.push(attachment.id);
+                    (_d = this.adapter.state.toDevRev) === null || _d === void 0 ? void 0 : _d.attachmentsMetadata.lastProcessedAttachmentsIdsList.push({ id: attachment.id, parent_id: attachment.parent_id });
                 }
                 await this.updateProgress();
             }
             catch (error) {
-                console.warn(`Skipping attachment with ID ${attachment.id} due to error in processAttachment function`, error);
+                const fileExtension = attachment.file_name.split('.').pop() || '';
+                const contentTypeInfo = attachment.content_type
+                    ? ` and content_type ${attachment.content_type}`
+                    : '';
+                console.warn(`Skipping attachment with ID ${attachment.id} with extension ${fileExtension}${contentTypeInfo} due to error in processAttachment function`, error);
                 await this.updateProgress();
             }
         }

package/dist/attachments-streaming/attachments-streaming-pool.test.js

@@ -44,10 +44,6 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 parent_id: 'parent-3',
             },
         ];
-        // Mock console methods
-        jest.spyOn(console, 'log').mockImplementation();
-        jest.spyOn(console, 'error').mockImplementation();
-        jest.spyOn(console, 'warn').mockImplementation();
     });
     afterEach(() => {
         jest.clearAllMocks();
@@ -60,7 +56,6 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 attachments: mockAttachments,
                 stream: mockStream,
             });
-            expect(pool).toBeDefined();
             expect(pool['adapter']).toBe(mockAdapter);
             expect(pool['attachments']).toEqual(mockAttachments);
             expect(pool['batchSize']).toBe(10);
@@ -135,11 +130,73 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             const result = await pool.streamAll();
             expect(result).toEqual({ delay: 5000 });
         });
+        it('should resume attachment extraction if it encounters old ids', async () => {
+            var _a;
+            // Test migration from old string[] format to new ProcessedAttachment[] format
+            // Using 'as any' because we're intentionally testing legacy data format
+            mockAdapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
+                ['attachment-1', 'attachment-2'];
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: mockAttachments,
+                stream: mockStream,
+            });
+            const result = await pool.streamAll();
+            expect((_a = mockAdapter.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
+                { id: 'attachment-1', parent_id: '' },
+                { id: 'attachment-2', parent_id: '' },
+                { id: 'attachment-1', parent_id: 'parent-1' },
+                { id: 'attachment-2', parent_id: 'parent-2' },
+                { id: 'attachment-3', parent_id: 'parent-3' },
+            ]);
+            expect(result).toEqual({});
+        });
+        it('should handle all attachments failing with different file types and sizes', async () => {
+            const largeAttachments = [
+                {
+                    id: 'attachment-image',
+                    url: 'https://example.com/photo.jpg',
+                    file_name: 'photo.jpg',
+                    parent_id: 'parent-1',
+                },
+                {
+                    id: 'attachment-pdf',
+                    url: 'https://example.com/document.pdf',
+                    file_name: 'document.pdf',
+                    parent_id: 'parent-2',
+                },
+                {
+                    id: 'attachment-video',
+                    url: 'https://example.com/video.mp4',
+                    file_name: 'video.mp4',
+                    parent_id: 'parent-3',
+                },
+            ];
+            const imageError = new Error('Image upload failed: File too large');
+            const pdfError = new Error('PDF upload failed: Unsupported format');
+            const videoError = new Error('Video upload failed: Network error');
+            mockAdapter.processAttachment
+                .mockRejectedValueOnce(imageError)
+                .mockRejectedValueOnce(pdfError)
+                .mockRejectedValueOnce(videoError);
+            const warnSpy = jest.spyOn(console, 'warn');
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: largeAttachments,
+                stream: mockStream,
+            });
+            await pool.streamAll();
+            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
+            // Since there are 3 parallel workers (one per attachment), each logs its own failed attachment
+            expect(warnSpy).toHaveBeenCalledTimes(3);
+            expect(mockAdapter.state.toDevRev.attachmentsMetadata
+                .lastProcessedAttachmentsIdsList).toEqual([]);
+        });
     });
     describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.startPoolStreaming.name, () => {
         it('should skip already processed attachments', async () => {
             mockAdapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
-                ['attachment-1'];
+                [{ id: 'attachment-1', parent_id: 'parent-1' }];
             mockAdapter.processAttachment.mockResolvedValue({});
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
@@ -158,9 +215,14 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             });
             await pool.streamAll();
             expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual(['attachment-1', 'attachment-2', 'attachment-3']);
+                .lastProcessedAttachmentsIdsList).toEqual([
+                { id: 'attachment-1', parent_id: 'parent-1' },
+                { id: 'attachment-2', parent_id: 'parent-2' },
+                { id: 'attachment-3', parent_id: 'parent-3' },
+            ]);
         });
         it('should handle processing errors gracefully', async () => {
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
             const error = new Error('Processing failed');
             mockAdapter.processAttachment
                 .mockResolvedValueOnce({}) // First attachment succeeds
@@ -172,9 +234,18 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 stream: mockStream,
             });
             await pool.streamAll();
-            expect(console.warn).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 due to error in processAttachment function', error);
+            expect(warnSpy).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 with extension jpg due to error in processAttachment function', error);
             expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual(['attachment-1', 'attachment-3']);
+                .lastProcessedAttachmentsIdsList).toEqual([
+                {
+                    id: 'attachment-1',
+                    parent_id: 'parent-1',
+                },
+                {
+                    id: 'attachment-3',
+                    parent_id: 'parent-3',
+                },
+            ]);
         });
         it('should stop processing when rate limit delay is encountered', async () => {
             mockAdapter.processAttachment
@@ -189,7 +260,10 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             await pool.streamAll();
             expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
             expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual(['attachment-1', 'attachment-3']);
+                .lastProcessedAttachmentsIdsList).toEqual([
+                { id: 'attachment-1', parent_id: 'parent-1' },
+                { id: 'attachment-3', parent_id: 'parent-3' },
+            ]);
         });
         it('should pass correct parameters to processAttachment', async () => {
             mockAdapter.processAttachment.mockResolvedValue({});
@@ -224,6 +298,23 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         await pool.streamAll();
         expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
     });
+    it('[edge] should upload attachments with same id, but different parent_id', async () => {
+        mockAdapter.processAttachment.mockResolvedValue({});
+        mockAttachments.push({
+            id: 'attachment-1',
+            url: 'http://example.com/file5.jpg',
+            file_name: 'file5.jpg',
+            parent_id: 'parent-4',
+        });
+        const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+            adapter: mockAdapter,
+            attachments: mockAttachments,
+            batchSize: 1,
+            stream: mockStream,
+        });
+        await pool.streamAll();
+        expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(4);
+    });
     it('[edge] should handle batch size of 1', async () => {
         mockAdapter.processAttachment.mockResolvedValue({});
         const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
@@ -235,6 +326,117 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         await pool.streamAll();
         expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
     });
+    describe('content_type handling', () => {
+        it('should pass attachment with content_type to processAttachment', async () => {
+            mockAdapter.processAttachment.mockResolvedValue({});
+            const attachmentWithContentType = {
+                id: 'attachment-ct',
+                url: 'https://example.com/report.pdf',
+                file_name: 'report.pdf',
+                parent_id: 'parent-ct',
+                content_type: 'application/pdf',
+            };
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: [attachmentWithContentType],
+                stream: mockStream,
+            });
+            await pool.streamAll();
+            expect(mockAdapter.processAttachment).toHaveBeenCalledWith(attachmentWithContentType, mockStream);
+            expect(mockAdapter.processAttachment.mock.calls[0][0].content_type).toBe('application/pdf');
+        });
+        it('should handle mixed attachments with and without content_type', async () => {
+            mockAdapter.processAttachment.mockResolvedValue({});
+            const mixedAttachments = [
+                {
+                    id: 'att-with-ct',
+                    url: 'https://example.com/image.png',
+                    file_name: 'image.png',
+                    parent_id: 'parent-1',
+                    content_type: 'image/png',
+                },
+                {
+                    id: 'att-without-ct',
+                    url: 'https://example.com/file.bin',
+                    file_name: 'file.bin',
+                    parent_id: 'parent-2',
+                },
+                {
+                    id: 'att-with-ct-2',
+                    url: 'https://example.com/doc.pdf',
+                    file_name: 'doc.pdf',
+                    parent_id: 'parent-3',
+                    content_type: 'application/pdf',
+                },
+            ];
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: mixedAttachments,
+                batchSize: 1,
+                stream: mockStream,
+            });
+            await pool.streamAll();
+            expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
+            expect(mockAdapter.processAttachment.mock.calls[0][0].content_type).toBe('image/png');
+            expect(mockAdapter.processAttachment.mock.calls[1][0].content_type).toBeUndefined();
+            expect(mockAdapter.processAttachment.mock.calls[2][0].content_type).toBe('application/pdf');
+        });
+        it('should include content_type in error log when processAttachment returns error', async () => {
+            mockAdapter.processAttachment.mockResolvedValue({
+                error: { message: 'Upload failed' },
+            });
+            const warnSpy = jest.spyOn(console, 'warn');
+            const attachmentWithContentType = {
+                id: 'att-error-ct',
+                url: 'https://example.com/file.pdf',
+                file_name: 'file.pdf',
+                parent_id: 'parent-err',
+                content_type: 'application/pdf',
+            };
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: [attachmentWithContentType],
+                batchSize: 1,
+                stream: mockStream,
+            });
+            await pool.streamAll();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('content_type application/pdf'), expect.any(String));
+        });
+        it('should include content_type in error log when processAttachment throws', async () => {
+            const error = new Error('Processing crashed');
+            mockAdapter.processAttachment.mockRejectedValue(error);
+            const warnSpy = jest.spyOn(console, 'warn');
+            const attachmentWithContentType = {
+                id: 'att-throw-ct',
+                url: 'https://example.com/file.png',
+                file_name: 'file.png',
+                parent_id: 'parent-throw',
+                content_type: 'image/png',
+            };
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: [attachmentWithContentType],
+                batchSize: 1,
+                stream: mockStream,
+            });
+            await pool.streamAll();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('content_type image/png'), error);
+        });
+        it('should not include content_type in error log when content_type is not set', async () => {
+            mockAdapter.processAttachment.mockResolvedValue({
+                error: { message: 'Upload failed' },
+            });
+            const warnSpy = jest.spyOn(console, 'warn');
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: [mockAttachments[0]],
+                batchSize: 1,
+                stream: mockStream,
+            });
+            await pool.streamAll();
+            expect(warnSpy).toHaveBeenCalledWith(expect.not.stringContaining('content_type'), expect.any(String));
+        });
+    });
     describe('concurrency behavior', () => {
         it('should process attachments concurrently within batch size', async () => {
             let processCallCount = 0;
@@ -264,4 +466,51 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             expect(endTime - startTime).toBeLessThan(250);
         });
     });
+    describe('log context attribution', () => {
+        it('should emit SDK-generated logs from pool (Starting download message)', async () => {
+            const logSpy = jest.spyOn(console, 'log');
+            mockAdapter.processAttachment.mockResolvedValue({});
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: mockAttachments.slice(0, 1),
+                stream: mockStream,
+            });
+            // Call streamAll - it should log "Starting download of N attachments..."
+            await pool.streamAll();
+            // Verify the SDK-generated "Starting download" message was logged
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Starting download of 1 attachments'));
+        });
+        it('should process user stream callback correctly while maintaining context isolation', async () => {
+            let userCallbackExecuted = false;
+            // Mock stream to capture context info
+            const mockStreamFn = jest
+                .fn()
+                .mockImplementation(async () => {
+                await Promise.resolve();
+                userCallbackExecuted = true;
+                // Record that the callback executed
+                return Promise.resolve({
+                    httpStream: undefined,
+                    error: undefined,
+                });
+            });
+            mockAdapter.processAttachment.mockImplementation(async (attachment, stream) => {
+                // processAttachment should be called with the user's stream function
+                const result = await stream({
+                    item: attachment,
+                    event: {},
+                });
+                return result;
+            });
+            const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
+                adapter: mockAdapter,
+                attachments: mockAttachments.slice(0, 1),
+                stream: mockStreamFn,
+            });
+            await pool.streamAll();
+            // Verify the user callback was executed
+            expect(userCallbackExecuted).toBe(true);
+            expect(mockStreamFn).toHaveBeenCalled();
+        });
+    });
 });

package/dist/common/constants.d.ts

@@ -12,14 +12,25 @@ export declare const ARTIFACT_BATCH_SIZE = 2000;
 export declare const MAX_DEVREV_ARTIFACT_SIZE: number;
 export declare const MAX_DEVREV_FILENAME_LENGTH = 256;
 export declare const MAX_DEVREV_FILENAME_EXTENSION_LENGTH = 20;
-export declare const AIRDROP_DEFAULT_ITEM_TYPES: {
-    EXTERNAL_DOMAIN_METADATA: string;
-    ATTACHMENTS: string;
-    SSOR_ATTACHMENT: string;
-};
+export declare const MAX_EVENT_SIZE_BYTES = 200000;
+export declare const EVENT_SIZE_THRESHOLD_BYTES: number;
+export declare const SSOR_ATTACHMENT: string;
+export declare enum AirSyncDefaultItemTypes {
+    EXTERNAL_DOMAIN_METADATA = "external_domain_metadata",
+    ATTACHMENTS = "attachments",
+    EXTERNAL_SYNC_UNITS = "external_sync_units"
+}
 export declare const LIBRARY_VERSION: any;
 export declare const DEFAULT_LAMBDA_TIMEOUT: number;
 export declare const HARD_TIMEOUT_MULTIPLIER = 1.3;
 export declare const MEMORY_LOG_INTERVAL: number;
 export declare const DEFAULT_SLEEP_DELAY_MS: number;
+/**
+ * Sentinel value representing an unbounded (no limit) extraction timestamp.
+ * Used as the resolved value for TimeValueType.UNBOUNDED, stored as workersOldest
+ * when the initial import has no lower time bound. The Unix epoch ensures that
+ * no real extraction timestamp can be earlier, preventing accidental overwrites
+ * of the boundary by subsequent syncs (e.g. reconciliation with absolute dates).
+ */
+export declare const UNBOUNDED_DATE_TIME_VALUE = "1970-01-01T00:00:00.000Z";
 //# sourceMappingURL=constants.d.ts.map

package/dist/common/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,eAAO,MAAM,8BAA8B,aAS1C,CAAC;AAEF,eAAO,MAAM,2BAA2B,aAKvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,aAG/B,CAAC;AAEF,eAAO,MAAM,gCAAgC,aAI5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAGjC,CAAC;AAEF,eAAO,MAAM,+BAA+B,aAGzC,CAAC;AAEJ,eAAO,MAAM,4BAA4B,aAExC,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAGhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,wBAAwB,QAAyB,CAAC;AAC/D,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,eAAO,MAAM,0BAA0B;;;;CAItC,CAAC;AAEF,eAAO,MAAM,eAAe,KAAsB,CAAC;AAEnD,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AACrD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,eAAO,MAAM,sBAAsB,QAAgB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,eAAO,MAAM,8BAA8B,aAS1C,CAAC;AAEF,eAAO,MAAM,2BAA2B,aAKvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,aAG/B,CAAC;AAEF,eAAO,MAAM,gCAAgC,aAI5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAGjC,CAAC;AAEF,eAAO,MAAM,+BAA+B,aAGzC,CAAC;AAEJ,eAAO,MAAM,4BAA4B,aAExC,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAGhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,wBAAwB,QAAyB,CAAC;AAC/D,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAGvD,eAAO,MAAM,oBAAoB,SAAU,CAAC;AAE5C,eAAO,MAAM,0BAA0B,QAEtC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAA0B,CAAC;AAEzD,oBAAY,uBAAuB;IACjC,wBAAwB,6BAA6B;IACrD,WAAW,gBAAgB;IAC3B,mBAAmB,wBAAwB;CAC5C;AAED,eAAO,MAAM,eAAe,KAAsB,CAAC;AAEnD,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AACrD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,eAAO,MAAM,sBAAsB,QAAgB,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,6BAA6B,CAAC"}

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SLEEP_DELAY_MS = exports.MEMORY_LOG_INTERVAL = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.STATEFUL_EVENT_TYPES = exports.STATEFUL_LOADING_EVENT_TYPES = exports.STATEFUL_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = exports.STATELESS_LOADING_EVENT_TYPES = exports.STATELESS_EXTRACTION_EVENT_TYPES = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = void 0;
+exports.UNBOUNDED_DATE_TIME_VALUE = exports.DEFAULT_SLEEP_DELAY_MS = exports.MEMORY_LOG_INTERVAL = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AirSyncDefaultItemTypes = exports.SSOR_ATTACHMENT = exports.EVENT_SIZE_THRESHOLD_BYTES = exports.MAX_EVENT_SIZE_BYTES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.STATEFUL_EVENT_TYPES = exports.STATEFUL_LOADING_EVENT_TYPES = exports.STATEFUL_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = exports.STATELESS_LOADING_EVENT_TYPES = exports.STATELESS_EXTRACTION_EVENT_TYPES = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = void 0;
 const extraction_1 = require("../types/extraction");
 const helpers_1 = require("./helpers");
 exports.ALLOWED_EXTRACTION_EVENT_TYPES = [
@@ -46,13 +46,27 @@ exports.ARTIFACT_BATCH_SIZE = 2000;
 exports.MAX_DEVREV_ARTIFACT_SIZE = 2 * 1024 * 1024 * 1024; // 2GB
 exports.MAX_DEVREV_FILENAME_LENGTH = 256;
 exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = 20; // 20 characters for the file extension
-exports.AIRDROP_DEFAULT_ITEM_TYPES = {
-    EXTERNAL_DOMAIN_METADATA: 'external_domain_metadata',
-    ATTACHMENTS: 'attachments',
-    SSOR_ATTACHMENT: 'ssor_attachment',
-};
+// Max SQS message size is 250KB, we want to leave some room for the other data in the message
+exports.MAX_EVENT_SIZE_BYTES = 200000;
+// We want to leave some room for the other data in the message and process the rest of queued messages
+exports.EVENT_SIZE_THRESHOLD_BYTES = Math.floor(exports.MAX_EVENT_SIZE_BYTES * 0.8);
+exports.SSOR_ATTACHMENT = 'ssor_attachment';
+var AirSyncDefaultItemTypes;
+(function (AirSyncDefaultItemTypes) {
+    AirSyncDefaultItemTypes["EXTERNAL_DOMAIN_METADATA"] = "external_domain_metadata";
+    AirSyncDefaultItemTypes["ATTACHMENTS"] = "attachments";
+    AirSyncDefaultItemTypes["EXTERNAL_SYNC_UNITS"] = "external_sync_units";
+})(AirSyncDefaultItemTypes || (exports.AirSyncDefaultItemTypes = AirSyncDefaultItemTypes = {}));
 exports.LIBRARY_VERSION = (0, helpers_1.getLibraryVersion)();
 exports.DEFAULT_LAMBDA_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 exports.HARD_TIMEOUT_MULTIPLIER = 1.3;
 exports.MEMORY_LOG_INTERVAL = 30 * 1000; // 30 seconds
 exports.DEFAULT_SLEEP_DELAY_MS = 3 * 60 * 1000; // 3 minutes
+/**
+ * Sentinel value representing an unbounded (no limit) extraction timestamp.
+ * Used as the resolved value for TimeValueType.UNBOUNDED, stored as workersOldest
+ * when the initial import has no lower time bound. The Unix epoch ensures that
+ * no real extraction timestamp can be earlier, preventing accidental overwrites
+ * of the boundary by subsequent syncs (e.g. reconciliation with absolute dates).
+ */
+exports.UNBOUNDED_DATE_TIME_VALUE = '1970-01-01T00:00:00.000Z';

package/dist/common/control-protocol.d.ts

@@ -1,8 +1,8 @@
 import { AxiosResponse } from 'axios';
-import { AirdropEvent, EventData, ExtractorEventType } from '../types/extraction';
+import { AirSyncEvent, EventData, ExtractorEventType } from '../types/extraction';
 import { LoaderEventType } from '../types/loading';
 export interface EmitInterface {
-    event: AirdropEvent;
+    event: AirSyncEvent;
     eventType: ExtractorEventType | LoaderEventType;
     data?: EventData;
 }

package/dist/common/control-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control-protocol.d.ts","sourceRoot":"","sources":["../../src/common/control-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAInD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,eAAO,MAAM,IAAI,GAAU,6BAIxB,aAAa,KAAG,OAAO,CAAC,aAAa,CAgCvC,CAAC"}
+{"version":3,"file":"control-protocol.d.ts","sourceRoot":"","sources":["../../src/common/control-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EACL,YAAY,EACZ,SAAS,EAET,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,eAAO,MAAM,IAAI,GAAU,6BAIxB,aAAa,KAAG,OAAO,CAAC,aAAa,CA4BvC,CAAC"}

package/dist/common/control-protocol.js

@@ -3,13 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.emit = void 0;
 const axios_client_internal_1 = require("../http/axios-client-internal");
 const constants_1 = require("./constants");
-const event_type_translation_1 = require("./event-type-translation");
 const emit = async ({ event, eventType, data, }) => {
-    // Translate outgoing event type to ensure we always send new event types
-    // TODO: Remove when the old types are completely phased out
-    const translatedEventType = (0, event_type_translation_1.translateOutgoingEventType)(eventType);
     const newEvent = {
-        event_type: translatedEventType,
+        event_type: eventType,
         event_context: event.payload.event_context,
         event_data: Object.assign({}, data),
         worker_metadata: {

package/dist/common/helpers.d.ts

@@ -38,4 +38,12 @@ export interface MemoryInfo {
  * @returns {MemoryInfo} The memory usage information
  */
 export declare function getMemoryUsage(): MemoryInfo;
+/**
+ * Truncates a message if it exceeds the maximum allowed length.
+ * Adds a suffix indicating how many characters were omitted.
+ *
+ * @param message - The message to truncate
+ * @returns Truncated message or original if within limits
+ */
+export declare function truncateMessage(message: string): string;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/common/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/common/helpers.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAgB,iBAAiB,QAiBhC;AAED;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAGrC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBzD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,UAAU,CAmD3C"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/common/helpers.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,wBAAgB,iBAAiB,QAiBhC;AAED;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAGrC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBzD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,UAAU,CAmD3C;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAOvD"}

package/dist/common/helpers.js

@@ -37,10 +37,12 @@ exports.getLibraryVersion = getLibraryVersion;
 exports.sleep = sleep;
 exports.truncateFilename = truncateFilename;
 exports.getMemoryUsage = getMemoryUsage;
+exports.truncateMessage = truncateMessage;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const v8 = __importStar(require("v8"));
 const constants_1 = require("./constants");
+const logger_constants_1 = require("../logger/logger.constants");
 /**
  * Gets the library version from the package.json file.
  * @returns {string} The library version
@@ -122,3 +124,16 @@ function getMemoryUsage() {
         throw err;
     }
 }
+/**
+ * Truncates a message if it exceeds the maximum allowed length.
+ * Adds a suffix indicating how many characters were omitted.
+ *
+ * @param message - The message to truncate
+ * @returns Truncated message or original if within limits
+ */
+function truncateMessage(message) {
+    if (message.length > logger_constants_1.MAX_LOG_STRING_LENGTH) {
+        return `${message.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${message.length - logger_constants_1.MAX_LOG_STRING_LENGTH} more characters`;
+    }
+    return message;
+}

package/dist/common/install-initial-domain-mapping.d.ts

@@ -1,4 +1,4 @@
-import { AirdropEvent } from '../types/extraction';
+import { AirSyncEvent } from '../types/extraction';
 import { InitialDomainMapping } from '../types/common';
-export declare function installInitialDomainMapping(event: AirdropEvent, initialDomainMappingJson: InitialDomainMapping): Promise<void>;
+export declare function installInitialDomainMapping(event: AirSyncEvent, initialDomainMappingJson: InitialDomainMapping): Promise<void>;
 //# sourceMappingURL=install-initial-domain-mapping.d.ts.map

package/dist/common/install-initial-domain-mapping.test.js

@@ -5,7 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
 const axios_client_internal_1 = require("../http/axios-client-internal");
-const test_helpers_1 = require("../tests/test-helpers");
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("./test-utils");
 const extraction_1 = require("../types/extraction");
 const install_initial_domain_mapping_1 = require("./install-initial-domain-mapping");
 // Mock dependencies
@@ -22,7 +23,9 @@ const mockAxiosClient = axios_client_internal_1.axiosClient;
 const mockIsAxiosError = axios_1.default.isAxiosError;
 describe(install_initial_domain_mapping_1.installInitialDomainMapping.name, () => {
     // Create mock objects
-    const mockEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
+    const mockEvent = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+        payload: { event_type: extraction_1.EventType.StartExtractingData },
+    });
     const mockInitialDomainMapping = {
         starting_recipe_blueprint: {
             name: 'Test Recipe Blueprint',
@@ -40,7 +43,8 @@ describe(install_initial_domain_mapping_1.installInitialDomainMapping.name, () =
             },
         },
     };
-    const mockEndpoint = 'http://localhost:3001';
+    // Use the endpoint from the event to support dynamic ports in parallel tests
+    const mockEndpoint = mockEvent.execution_metadata.devrev_endpoint;
     const mockToken = 'test_token';
     // After each test, clear all mocks to prevent state from leaking.
     afterEach(() => {