@devrev/airsync-sdk 2.0.0-beta.1 → 2.0.0-beta.3

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

@@ -3,12 +3,13 @@ import { AttachmentsStreamingPoolParams } from './attachments-streaming-pool.int
 export declare class AttachmentsStreamingPool<ConnectorState> {
     private adapter;
     private attachments;
+    private attachmentsMetadata;
     private batchSize;
     private delay;
     private stream;
     private totalProcessedCount;
     private readonly PROGRESS_REPORT_INTERVAL;
-    constructor({ adapter, attachments, batchSize, stream, }: AttachmentsStreamingPoolParams<ConnectorState>);
+    constructor({ adapter, attachments, attachmentsMetadata, batchSize, stream, }: AttachmentsStreamingPoolParams<ConnectorState>);
     private updateProgress;
     /**
      * Migrates processed attachments from the legacy string[] format to the new ProcessedAttachment[] format.

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;AAGzF,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;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,CAAoC;IACnD,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,mBAAmB,CAA8C;IACzE,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,mBAAmB,EACnB,SAAc,EACd,MAAM,GACP,EAAE,8BAA8B,CAAC,cAAc,CAAC;YASnC,cAAc;IAS5B;;;;;OAKG;IAEH,OAAO,CAAC,2BAA2B;IAsB7B,SAAS,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAyCjD,kBAAkB;CAuFzB"}

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

@@ -1,8 +1,14 @@
 import { ExternalSystemAttachmentStreamingFunction, NormalizedAttachment } from '../types';
-import { WorkerAdapter } from '../multithreading/worker-adapter/worker-adapter';
+import { ExtractionAdapter } from '../multithreading/adapters/extraction-adapter';
+import { ToDevRev } from '../state/state.interfaces';
 export interface AttachmentsStreamingPoolParams<ConnectorState> {
-    adapter: WorkerAdapter<ConnectorState>;
+    adapter: ExtractionAdapter<ConnectorState>;
     attachments: NormalizedAttachment[];
+    /**
+     * SDK-owned attachments bookkeeping. Passed in directly so the pool does not
+     * reach into the (now-encapsulated) adapter state.
+     */
+    attachmentsMetadata: ToDevRev['attachmentsMetadata'] | undefined;
     batchSize?: number;
     stream: ExternalSystemAttachmentStreamingFunction;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"attachments-streaming-pool.interfaces.d.ts","sourceRoot":"","sources":["../../src/attachments-streaming/attachments-streaming-pool.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yCAAyC,EACzC,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAEhF,MAAM,WAAW,8BAA8B,CAAC,cAAc;IAC5D,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACvC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,yCAAyC,CAAC;CACnD"}
+{"version":3,"file":"attachments-streaming-pool.interfaces.d.ts","sourceRoot":"","sources":["../../src/attachments-streaming/attachments-streaming-pool.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yCAAyC,EACzC,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAErD,MAAM,WAAW,8BAA8B,CAAC,cAAc;IAC5D,OAAO,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAC3C,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC;;;OAGG;IACH,mBAAmB,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GAAG,SAAS,CAAC;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,yCAAyC,CAAC;CACnD"}

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

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AttachmentsStreamingPool = void 0;
 const helpers_1 = require("../common/helpers");
 class AttachmentsStreamingPool {
-    constructor({ adapter, attachments, batchSize = 10, stream, }) {
+    constructor({ adapter, attachments, attachmentsMetadata, batchSize = 10, stream, }) {
         this.totalProcessedCount = 0;
         this.PROGRESS_REPORT_INTERVAL = 50;
         this.adapter = adapter;
         this.attachments = [...attachments]; // Create a copy we can mutate
+        this.attachmentsMetadata = attachmentsMetadata;
         this.batchSize = batchSize;
         this.delay = undefined;
         this.stream = stream;
@@ -47,22 +48,19 @@ class AttachmentsStreamingPool {
     }
     async streamAll() {
         console.log(`Starting download of ${this.attachments.length} attachments, streaming ${this.batchSize} at once.`);
-        if (!this.adapter.state.toDevRev) {
+        if (!this.attachmentsMetadata) {
             const error = new Error('toDevRev state is not initialized');
             console.error(error);
             return { error };
         }
         // Get the list of successfully processed attachments in previous (possibly incomplete) batch extraction.
         // If no such list exists, create an empty one.
-        if (!this.adapter.state.toDevRev.attachmentsMetadata
-            .lastProcessedAttachmentsIdsList) {
-            this.adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
-                [];
+        if (!this.attachmentsMetadata.lastProcessedAttachmentsIdsList) {
+            this.attachmentsMetadata.lastProcessedAttachmentsIdsList = [];
         }
         // Migrate old processed attachments to the new format.
-        this.adapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
-            this.migrateProcessedAttachments(this.adapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList);
+        this.attachmentsMetadata.lastProcessedAttachmentsIdsList =
+            this.migrateProcessedAttachments(this.attachmentsMetadata.lastProcessedAttachmentsIdsList);
         // Start initial batch of promises up to batchSize limit
         const initialBatchSize = Math.min(this.batchSize, this.attachments.length);
         const initialPromises = [];
@@ -77,7 +75,7 @@ class AttachmentsStreamingPool {
         return {};
     }
     async startPoolStreaming() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         // Process attachments until the attachments array is empty
         while (this.attachments.length > 0) {
             // If delay is set, stop streaming
@@ -94,8 +92,7 @@ class AttachmentsStreamingPool {
             if (!attachment) {
                 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.some((it) => it.id == attachment.id && it.parent_id == attachment.parent_id))) {
+            if ((_b = (_a = this.attachmentsMetadata) === null || _a === void 0 ? void 0 : _a.lastProcessedAttachmentsIdsList) === null || _b === void 0 ? void 0 : _b.some((it) => it.id == attachment.id && it.parent_id == attachment.parent_id)) {
                 continue; // Skip if the attachment ID is already processed
             }
             try {
@@ -106,18 +103,32 @@ 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({ id: attachment.id, parent_id: attachment.parent_id });
+                if ((_c = this.attachmentsMetadata) === null || _c === void 0 ? void 0 : _c.lastProcessedAttachmentsIdsList) {
+                    this.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

@@ -6,16 +6,18 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
     let mockAdapter;
     let mockStream;
     let mockAttachments;
+    let attachmentsMetadata;
     beforeEach(() => {
+        // SDK-owned attachments bookkeeping, passed into the pool directly.
+        attachmentsMetadata = {
+            artifactIds: [],
+            lastProcessed: 0,
+            lastProcessedAttachmentsIdsList: [],
+        };
         // Create mock adapter
         mockAdapter = {
             state: {
                 attachments: { completed: false },
-                toDevRev: {
-                    attachmentsMetadata: {
-                        lastProcessedAttachmentsIdsList: [],
-                    },
-                },
             },
             processAttachment: jest
                 .fn()
@@ -44,10 +46,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();
@@ -57,10 +55,10 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         it('should initialize with default values', () => {
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
-            expect(pool).toBeDefined();
             expect(pool['adapter']).toBe(mockAdapter);
             expect(pool['attachments']).toEqual(mockAttachments);
             expect(pool['batchSize']).toBe(10);
@@ -69,6 +67,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         it('should initialize with custom batch size', () => {
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 batchSize: 5,
                 stream: mockStream,
@@ -78,6 +77,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         it('should create a copy of attachments array', () => {
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
@@ -87,11 +87,11 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
     });
     describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.streamAll.name, () => {
         it('should initialize lastProcessedAttachmentsIdsList if it does not exist', async () => {
-            mockAdapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
-                undefined;
+            attachmentsMetadata.lastProcessedAttachmentsIdsList = undefined;
             mockAdapter.processAttachment.mockResolvedValue({});
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
@@ -100,13 +100,13 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 .spyOn(pool, 'startPoolStreaming')
                 .mockResolvedValue(undefined);
             await pool.streamAll();
-            expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual([]);
+            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([]);
         });
         it('should process all attachments successfully', async () => {
             mockAdapter.processAttachment.mockResolvedValue({});
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
@@ -117,6 +117,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         it('should handle empty attachments array', async () => {
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: [],
                 stream: mockStream,
             });
@@ -129,6 +130,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             mockAdapter.processAttachment.mockResolvedValue(delayResponse);
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
@@ -136,18 +138,20 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             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'];
+            attachmentsMetadata.lastProcessedAttachmentsIdsList = [
+                'attachment-1',
+                'attachment-2',
+            ];
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
             const result = await pool.streamAll();
-            expect((_a = mockAdapter.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
+            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
                 { id: 'attachment-1', parent_id: '' },
                 { id: 'attachment-2', parent_id: '' },
                 { id: 'attachment-1', parent_id: 'parent-1' },
@@ -156,14 +160,57 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             ]);
             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,
+                attachmentsMetadata,
+                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(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([]);
+        });
     });
     describe(attachments_streaming_pool_1.AttachmentsStreamingPool.prototype.startPoolStreaming.name, () => {
         it('should skip already processed attachments', async () => {
-            mockAdapter.state.toDevRev.attachmentsMetadata.lastProcessedAttachmentsIdsList =
-                [{ id: 'attachment-1', parent_id: 'parent-1' }];
+            attachmentsMetadata.lastProcessedAttachmentsIdsList = [
+                { id: 'attachment-1', parent_id: 'parent-1' },
+            ];
             mockAdapter.processAttachment.mockResolvedValue({});
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
@@ -174,18 +221,19 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             mockAdapter.processAttachment.mockResolvedValue({});
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
             await pool.streamAll();
-            expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual([
+            expect(attachmentsMetadata.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
@@ -193,13 +241,13 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 .mockResolvedValueOnce({}); // Third attachment succeeds
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
             await pool.streamAll();
-            expect(console.warn).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 due to error in processAttachment function', error);
-            expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual([
+            expect(warnSpy).toHaveBeenCalledWith('Skipping attachment with ID attachment-2 with extension jpg due to error in processAttachment function', error);
+            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
                 {
                     id: 'attachment-1',
                     parent_id: 'parent-1',
@@ -217,13 +265,13 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
                 .mockResolvedValueOnce({}); // Third attachment succeeds
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 stream: mockStream,
             });
             await pool.streamAll();
             expect(mockAdapter.processAttachment).toHaveBeenCalledTimes(3);
-            expect(mockAdapter.state.toDevRev.attachmentsMetadata
-                .lastProcessedAttachmentsIdsList).toEqual([
+            expect(attachmentsMetadata.lastProcessedAttachmentsIdsList).toEqual([
                 { id: 'attachment-1', parent_id: 'parent-1' },
                 { id: 'attachment-3', parent_id: 'parent-3' },
             ]);
@@ -232,6 +280,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             mockAdapter.processAttachment.mockResolvedValue({});
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: [mockAttachments[0]],
                 stream: mockStream,
             });
@@ -243,6 +292,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         mockAdapter.processAttachment.mockResolvedValue({});
         const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
             adapter: mockAdapter,
+            attachmentsMetadata,
             attachments: [mockAttachments[0]],
             stream: mockStream,
         });
@@ -254,6 +304,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         mockAdapter.processAttachment.mockResolvedValue({});
         const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
             adapter: mockAdapter,
+            attachmentsMetadata,
             attachments: mockAttachments,
             batchSize: 100,
             stream: mockStream,
@@ -271,6 +322,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         });
         const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
             adapter: mockAdapter,
+            attachmentsMetadata,
             attachments: mockAttachments,
             batchSize: 1,
             stream: mockStream,
@@ -282,6 +334,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
         mockAdapter.processAttachment.mockResolvedValue({});
         const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
             adapter: mockAdapter,
+            attachmentsMetadata,
             attachments: mockAttachments,
             batchSize: 1,
             stream: mockStream,
@@ -289,6 +342,122 @@ 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,
+                attachmentsMetadata,
+                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,
+                attachmentsMetadata,
+                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,
+                attachmentsMetadata,
+                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,
+                attachmentsMetadata,
+                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,
+                attachmentsMetadata,
+                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;
@@ -305,6 +474,7 @@ describe(attachments_streaming_pool_1.AttachmentsStreamingPool.name, () => {
             });
             const pool = new attachments_streaming_pool_1.AttachmentsStreamingPool({
                 adapter: mockAdapter,
+                attachmentsMetadata,
                 attachments: mockAttachments,
                 batchSize: 2,
                 stream: mockStream,
@@ -318,4 +488,53 @@ 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,
+                attachmentsMetadata,
+                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,
+                attachmentsMetadata,
+                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"}