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

package/dist/state/state.extract-window.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const extraction_state_1 = require("./extraction-state");
+describe('State — extraction window validation', () => {
+    let fetchStateSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        fetchStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'fetchState');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    describe('Enhanced Control Protocol - extraction window validation', () => {
+        it('should exit the process if extract_from >= extract_to', async () => {
+            // Arrange: start is after end (inverted window)
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act & Assert
+            await expect((0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            })).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should exit the process if extract_from equals extract_to', async () => {
+            // Arrange: start equals end (zero-width window)
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-06-01T00:00:00Z',
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act & Assert
+            await expect((0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            })).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should not exit when extract_from < extract_to', async () => {
+            // Arrange: valid window
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: process.exit should NOT have been called
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+        it('should not validate when only extract_from is set', async () => {
+            // Arrange: only start, no end
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2024-01-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: process.exit should NOT have been called
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+        it('should not exit when extract_from is UNBOUNDED and extract_to is a real timestamp', async () => {
+            // Arrange: UNBOUNDED start (epoch) with a real ABSOLUTE end timestamp
+            const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+                payload: {
+                    event_type: extraction_1.EventType.StartExtractingMetadata,
+                    event_context: {
+                        extraction_start_time: {
+                            type: extraction_1.TimeValueType.UNBOUNDED,
+                        },
+                        extraction_end_time: {
+                            type: extraction_1.TimeValueType.ABSOLUTE_TIME,
+                            value: '2025-06-01T00:00:00Z',
+                        },
+                    },
+                },
+            });
+            const stringifiedState = JSON.stringify({
+                snapInVersionId: 'test_snap_in_version_id',
+            });
+            fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+            // Act
+            await (0, extraction_state_1.createExtractionState)({
+                event,
+                initialState: {},
+                initialDomainMapping: {},
+            });
+            // Assert: process.exit should NOT have been called
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -1,19 +1,44 @@
 import { InitialDomainMapping } from '../types/common';
-import { AirdropEvent } from '../types/extraction';
+import { AirSyncEvent } from '../types/extraction';
 import { FileToLoad } from '../types/loading';
 import { WorkerAdapterOptions } from '../types/workers';
-export interface SdkState {
-    lastSyncStarted?: string;
-    lastSuccessfulSyncStarted?: string;
+/**
+ * BaseSdkState holds SDK bookkeeping common to every sync mode.
+ */
+export interface BaseSdkState {
+    snapInVersionId?: string;
+}
+/**
+ * ExtractionSdkState holds SDK bookkeeping owned by the extraction modes.
+ */
+export interface ExtractionSdkState extends BaseSdkState {
+    /** The pending (not yet committed) oldest extraction boundary (ISO 8601 timestamp).
+     *  Set on StartExtractingMetadata, reused across subsequent phases, cleared on AttachmentExtractionDone. */
+    pendingWorkersOldest?: string;
+    /** The pending (not yet committed) newest extraction boundary (ISO 8601 timestamp).
+     *  Set on StartExtractingMetadata, reused across subsequent phases, cleared on AttachmentExtractionDone. */
+    pendingWorkersNewest?: string;
+    /** The oldest point of extraction (ISO 8601 timestamp). */
+    workersOldest?: string;
+    /** The newest point of extraction (ISO 8601 timestamp). */
+    workersNewest?: string;
     toDevRev?: ToDevRev;
+}
+/**
+ * LoadingSdkState holds SDK bookkeeping owned by the loading modes.
+ */
+export interface LoadingSdkState extends BaseSdkState {
     fromDevRev?: FromDevRev;
-    snapInVersionId?: string;
 }
 /**
- * AdapterState is an interface that defines the structure of the adapter state that is used by the external extractor.
- * It extends the connector state with additional fields: lastSyncStarted, lastSuccessfulSyncStarted, snapInVersionId and attachmentsMetadata.
+ * AdapterStateEnvelope is the v2 on-disk state shape: connector state and SDK
+ * bookkeeping are stored as disjoint sub-objects so SDK internals stay
+ * encapsulated and never collide with connector keys.
  */
-export type AdapterState<ConnectorState> = ConnectorState & SdkState;
+export interface AdapterStateEnvelope<ConnectorState, SdkState extends BaseSdkState> {
+    connectorState: ConnectorState;
+    sdkState: SdkState;
+}
 export interface ToDevRev {
     attachmentsMetadata: {
         artifactIds: string[];
@@ -32,27 +57,19 @@ export interface FromDevRev {
     filesToLoad: FileToLoad[];
 }
 export interface StateInterface<ConnectorState> {
-    event: AirdropEvent;
+    event: AirSyncEvent;
     initialState: ConnectorState;
     initialDomainMapping?: InitialDomainMapping;
     options?: WorkerAdapterOptions;
 }
-export declare const extractionSdkState: {
-    lastSyncStarted: string;
-    lastSuccessfulSyncStarted: string;
-    snapInVersionId: string;
-    toDevRev: {
-        attachmentsMetadata: {
-            artifactIds: never[];
-            lastProcessed: number;
-            lastProcessedAttachmentsIdsList: never[];
-        };
-    };
-};
-export declare const loadingSdkState: {
-    snapInVersionId: string;
-    fromDevRev: {
-        filesToLoad: never[];
-    };
-};
+export declare const initialExtractionSdkState: ExtractionSdkState;
+export declare const initialLoadingSdkState: LoadingSdkState;
+/**
+ * The set of top-level state keys owned by the SDK. Derived from the initial
+ * SDK state constants so it auto-updates whenever a new SDK field is added.
+ * Used by the migration shim to split a flat v1 state blob into the
+ * `{ connectorState, sdkState }` envelope: keys in this set go to `sdkState`,
+ * everything else is connector state.
+ */
+export declare const V1_SDK_STATE_KEYS: ReadonlySet<string>;
 //# sourceMappingURL=state.interfaces.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"state.interfaces.d.ts","sourceRoot":"","sources":["../../src/state/state.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,cAAc,IAAI,cAAc,GAAG,QAAQ,CAAC;AAErE,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE;QACnB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,+BAA+B,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACzD,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc,CAAC,cAAc;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,cAAc,CAAC;IAC7B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;CAW9B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;CAK3B,CAAC"}
+{"version":3,"file":"state.interfaces.d.ts","sourceRoot":"","sources":["../../src/state/state.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACtD;gHAC4G;IAC5G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;gHAC4G;IAC5G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB,CACnC,cAAc,EACd,QAAQ,SAAS,YAAY;IAE7B,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE;QACnB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,+BAA+B,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACzD,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc,CAAC,cAAc;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,cAAc,CAAC;IAC7B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,eAAO,MAAM,yBAAyB,EAAE,kBAavC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAKpC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAGhD,CAAC"}

package/dist/state/state.interfaces.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadingSdkState = exports.extractionSdkState = void 0;
-exports.extractionSdkState = {
-    lastSyncStarted: '',
-    lastSuccessfulSyncStarted: '',
+exports.V1_SDK_STATE_KEYS = exports.initialLoadingSdkState = exports.initialExtractionSdkState = void 0;
+exports.initialExtractionSdkState = {
     snapInVersionId: '',
+    pendingWorkersOldest: '',
+    pendingWorkersNewest: '',
+    workersOldest: '',
+    workersNewest: '',
     toDevRev: {
         attachmentsMetadata: {
             artifactIds: [],
@@ -13,9 +15,20 @@ exports.extractionSdkState = {
         },
     },
 };
-exports.loadingSdkState = {
+exports.initialLoadingSdkState = {
     snapInVersionId: '',
     fromDevRev: {
         filesToLoad: [],
     },
 };
+/**
+ * The set of top-level state keys owned by the SDK. Derived from the initial
+ * SDK state constants so it auto-updates whenever a new SDK field is added.
+ * Used by the migration shim to split a flat v1 state blob into the
+ * `{ connectorState, sdkState }` envelope: keys in this set go to `sdkState`,
+ * everything else is connector state.
+ */
+exports.V1_SDK_STATE_KEYS = new Set([
+    ...Object.keys(exports.initialExtractionSdkState),
+    ...Object.keys(exports.initialLoadingSdkState),
+]);

package/dist/state/state.pending-boundaries.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.pending-boundaries.test.d.ts.map

package/dist/state/state.pending-boundaries.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.pending-boundaries.test.d.ts","sourceRoot":"","sources":["../../src/state/state.pending-boundaries.test.ts"],"names":[],"mappings":""}

package/dist/state/state.pending-boundaries.test.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const extraction_state_1 = require("./extraction-state");
+/* eslint-disable @typescript-eslint/no-require-imports */
+const FIXED_NOW = '2026-03-26T10:00:00.000Z';
+describe('State — pending extraction boundaries', () => {
+    let postStateSpy;
+    let fetchStateSpy;
+    let installInitialDomainMappingSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        postStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'fetchState');
+        installInitialDomainMappingSpy = jest.spyOn(require('../common/install-initial-domain-mapping'), 'installInitialDomainMapping');
+        jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date(FIXED_NOW));
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it('should store resolved values in pendingWorkersOldest/pendingWorkersNewest on StartExtractingMetadata', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: '',
+            },
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingMetadata,
+                event_context: {
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.UNBOUNDED,
+                    },
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                },
+            },
+        });
+        fetchStateSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        installInitialDomainMappingSpy.mockResolvedValue({ success: true });
+        postStateSpy.mockResolvedValue({ success: true });
+        // Act
+        const state = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(state.sdkState.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
+        expect(state.sdkState.pendingWorkersNewest).toBe(FIXED_NOW);
+        expect(event.payload.event_context.extract_from).toBe('1970-01-01T00:00:00.000Z');
+        expect(event.payload.event_context.extract_to).toBe(FIXED_NOW);
+    });
+    it('should overwrite pending values on a retry (new StartExtractingMetadata after failure)', async () => {
+        // Arrange: state has stale pending values from a previous failed attempt
+        const staleOldest = '2026-03-25T08:00:00.000Z';
+        const staleNewest = '2026-03-25T09:00:00.000Z';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: {
+                event_type: extraction_1.EventType.StartExtractingMetadata,
+                event_context: {
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.UNBOUNDED,
+                    },
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                },
+            },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+            pendingWorkersOldest: staleOldest,
+            pendingWorkersNewest: staleNewest,
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        const state = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: pending values are overwritten with fresh resolution, not stale values
+        expect(state.sdkState.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
+        expect(state.sdkState.pendingWorkersNewest).toBe(FIXED_NOW);
+        expect(state.sdkState.pendingWorkersNewest).not.toBe(staleNewest);
+    });
+    it('should reuse pending values from state on ContinueExtractingData instead of re-resolving', async () => {
+        // Arrange: state has pending values from a prior StartExtractingMetadata phase
+        const pendingOldest = '1970-01-01T00:00:00.000Z';
+        const pendingNewest = '2026-03-26T08:00:00.000Z'; // Earlier than FIXED_NOW
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: {
+                event_type: extraction_1.EventType.ContinueExtractingData,
+                event_context: {
+                    // Platform still sends TimeValue objects, but they should be ignored
+                    extraction_start_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                    extraction_end_time: {
+                        type: extraction_1.TimeValueType.CURRENT_TIME,
+                    },
+                },
+            },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+            pendingWorkersOldest: pendingOldest,
+            pendingWorkersNewest: pendingNewest,
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        const state = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: uses cached pending values, NOT new Date() resolution
+        expect(event.payload.event_context.extract_from).toBe(pendingOldest);
+        expect(event.payload.event_context.extract_to).toBe(pendingNewest);
+        // Pending values in state remain unchanged
+        expect(state.sdkState.pendingWorkersOldest).toBe(pendingOldest);
+        expect(state.sdkState.pendingWorkersNewest).toBe(pendingNewest);
+    });
+    it('should not set extract_from/extract_to on ContinueExtractingData if no pending values exist', async () => {
+        // Arrange: state has no pending values (e.g. old state from before this feature)
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: { event_type: extraction_1.EventType.ContinueExtractingData },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: no extraction timestamps are set
+        expect(event.payload.event_context.extract_from).toBeUndefined();
+        expect(event.payload.event_context.extract_to).toBeUndefined();
+    });
+    it('should reuse pending values on StartExtractingAttachments', async () => {
+        // Arrange: state has pending values from the StartExtractingMetadata phase
+        const pendingOldest = '1970-01-01T00:00:00.000Z';
+        const pendingNewest = '2026-03-26T08:00:00.000Z';
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: 'test_snap_in_version_id',
+            },
+            payload: { event_type: extraction_1.EventType.StartExtractingAttachments },
+        });
+        const stringifiedState = JSON.stringify({
+            snapInVersionId: 'test_snap_in_version_id',
+            pendingWorkersOldest: pendingOldest,
+            pendingWorkersNewest: pendingNewest,
+        });
+        fetchStateSpy.mockResolvedValue({ state: stringifiedState });
+        // Act
+        await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: pending values are reused
+        expect(event.payload.event_context.extract_from).toBe(pendingOldest);
+        expect(event.payload.event_context.extract_to).toBe(pendingNewest);
+    });
+});

package/dist/state/state.post-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.post-state.test.d.ts.map

package/dist/state/state.post-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.post-state.test.d.ts","sourceRoot":"","sources":["../../src/state/state.post-state.test.ts"],"names":[],"mappings":""}

package/dist/state/state.post-state.test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_setup_1 = require("../tests/jest.setup");
+const test_utils_1 = require("../common/test-utils");
+const extraction_1 = require("../types/extraction");
+const extraction_state_1 = require("./extraction-state");
+/* eslint-disable @typescript-eslint/no-require-imports */
+describe('State.postState', () => {
+    let postStateSpy;
+    let fetchStateSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        postStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(extraction_state_1.ExtractionState.prototype, 'fetchState');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    it('should POST the stringified state to the update endpoint', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: {
+                snap_in_version_id: '1.0.0',
+                secrets: { service_account_token: 'test_token' },
+            },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        const stateToPost = { snapInVersionId: '1.0.0', foo: 'bar' };
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+        });
+        postStateSpy.mockRestore();
+        const adapterState = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Act
+        await adapterState.postState(stateToPost);
+        // Assert: the mock server records all incoming requests — inspect what was sent
+        const requests = jest_setup_1.mockServer.getRequests('POST', '/worker_data_url.update');
+        expect(requests).toHaveLength(1);
+        const body = requests[0].body;
+        // Body must contain the stringified v2 envelope: connector state and SDK
+        // bookkeeping stored as disjoint sub-objects.
+        expect(typeof body.state).toBe('string');
+        const parsed = JSON.parse(body.state);
+        expect(parsed.connectorState.foo).toBe('bar');
+        expect(parsed.sdkState.snapInVersionId).toBe('1.0.0');
+    });
+    it('should exit(1) when postState HTTP request fails', async () => {
+        // Arrange
+        const event = (0, test_utils_1.createMockEvent)(jest_setup_1.mockServer.baseUrl, {
+            context: { snap_in_version_id: '1.0.0' },
+            payload: { event_type: extraction_1.EventType.StartExtractingData },
+        });
+        fetchStateSpy.mockResolvedValue({
+            state: JSON.stringify({ snapInVersionId: '1.0.0' }),
+        });
+        postStateSpy.mockRestore();
+        const adapterState = await (0, extraction_state_1.createExtractionState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Mock axiosClient.post directly to bypass the retry backoff
+        const axiosClientModule = require('../http/axios-client-internal');
+        const axiosPostSpy = jest
+            .spyOn(axiosClientModule.axiosClient, 'post')
+            .mockRejectedValue(new Error('network error'));
+        // Act & Assert
+        await expect(adapterState.postState()).rejects.toThrow('process.exit called');
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+        axiosPostSpy.mockRestore();
+    });
+});