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

package/dist/state/state.js

@@ -6,12 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.State = void 0;
 exports.createAdapterState = createAdapterState;
 const axios_1 = __importDefault(require("axios"));
+const node_worker_threads_1 = require("node:worker_threads");
 const constants_1 = require("../common/constants");
 const install_initial_domain_mapping_1 = require("../common/install-initial-domain-mapping");
+const time_value_resolver_1 = require("../common/time-value-resolver");
 const axios_client_internal_1 = require("../http/axios-client-internal");
 const logger_1 = require("../logger/logger");
 const common_1 = require("../types/common");
 const extraction_1 = require("../types/extraction");
+const workers_1 = require("../types/workers");
 const state_interfaces_1 = require("./state.interfaces");
 async function createAdapterState({ event, initialState, initialDomainMapping, options, }) {
     // Deep clone the initial state to avoid mutating the original state
@@ -43,21 +46,88 @@ async function createAdapterState({ event, initialState, initialDomainMapping, o
                 }
             }
             catch (error) {
-                console.error('Error while installing initial domain mapping.', (0, logger_1.serializeError)(error));
+                const errorMessage = `Error while installing initial domain mapping. ${(0, logger_1.serializeError)(error)}`;
+                console.error(errorMessage);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                    payload: { message: errorMessage },
+                });
                 process.exit(1);
             }
         }
-        // Set lastSyncStarted if the event type is StartExtractingData
-        if (event.payload.event_type === extraction_1.EventType.StartExtractingData &&
-            !as.state.lastSyncStarted) {
-            as.state.lastSyncStarted = new Date().toISOString();
-            console.log(`Setting lastSyncStarted to ${as.state.lastSyncStarted}.`);
+        // Resolve extraction timestamps from TimeValue objects, or reuse pending values from a prior invocation.
+        // On StartExtractingMetadata: resolve fresh from TimeValue objects and store in pending state (always overwrite).
+        // On all other events: reuse the pending values cached during StartExtractingMetadata.
+        const eventContext = event.payload.event_context;
+        if (event.payload.event_type === extraction_1.EventType.StartExtractingMetadata) {
+            const timeFields = [
+                {
+                    source: 'extraction_start_time',
+                    target: 'extract_from',
+                    pending: 'pendingWorkersOldest',
+                },
+                {
+                    source: 'extraction_end_time',
+                    target: 'extract_to',
+                    pending: 'pendingWorkersNewest',
+                },
+            ];
+            for (const { source, target, pending } of timeFields) {
+                const timeValue = eventContext[source];
+                if (timeValue && timeValue.type) {
+                    try {
+                        const resolved = (0, time_value_resolver_1.resolveTimeValue)(timeValue, as.state);
+                        eventContext[target] = resolved;
+                        as.state[pending] = resolved;
+                        console.log(`Resolved ${target} to ${resolved}. Stored in ${pending}.`);
+                    }
+                    catch (error) {
+                        const errorMessage = `Failed to resolve ${source}: ${(0, logger_1.serializeError)(error)}`;
+                        console.error(errorMessage);
+                        node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                            payload: { message: errorMessage },
+                        });
+                        process.exit(1);
+                    }
+                }
+            }
+        }
+        else {
+            // Non-StartExtractingMetadata events: reuse pending values from state
+            if (as.state.pendingWorkersOldest) {
+                eventContext.extract_from = as.state.pendingWorkersOldest;
+                console.log(`Reusing pendingWorkersOldest as extract_from: ${as.state.pendingWorkersOldest}.`);
+            }
+            else {
+                console.log('pendingWorkersOldest is not set in state. extract_from will not be populated for this invocation.');
+            }
+            if (as.state.pendingWorkersNewest) {
+                eventContext.extract_to = as.state.pendingWorkersNewest;
+                console.log(`Reusing pendingWorkersNewest as extract_to: ${as.state.pendingWorkersNewest}.`);
+            }
+            else {
+                console.log('pendingWorkersNewest is not set in state. extract_to will not be populated for this invocation.');
+            }
+        }
+        // Validate that extract_from is before extract_to
+        if (eventContext.extract_from && eventContext.extract_to) {
+            if (eventContext.extract_from >= eventContext.extract_to) {
+                const errorMessage = `Invalid extraction window: extract_from (${eventContext.extract_from}) must be older than extract_to (${eventContext.extract_to}). This indicates an error in the platform.`;
+                console.error(errorMessage);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                    payload: { message: errorMessage },
+                });
+                process.exit(1);
+            }
         }
     }
     return as;
 }
 class State {
     constructor({ event, initialState }) {
+        this._extractionScope = {};
         this.initialSdkState =
             event.payload.event_context.mode === common_1.SyncMode.LOADING
                 ? state_interfaces_1.loadingSdkState
@@ -74,6 +144,9 @@ class State {
     set state(value) {
         this._state = value;
     }
+    get extractionScope() {
+        return this._extractionScope;
+    }
     /**
      * Initializes the state for this adapter instance by fetching from API
      * or creating an initial state if none exists (404).
@@ -82,7 +155,7 @@ class State {
     async init(initialState) {
         var _a;
         try {
-            const stringifiedState = await this.fetchState();
+            const { state: stringifiedState, objects } = await this.fetchState();
             if (!stringifiedState) {
                 throw new Error('No state found in response.');
             }
@@ -95,6 +168,14 @@ class State {
             }
             this.state = parsedState;
             console.log('State fetched successfully. Current state', (0, logger_1.getPrintableState)(this.state));
+            if (objects) {
+                try {
+                    this._extractionScope = JSON.parse(objects);
+                }
+                catch (error) {
+                    console.warn(`Failed to parse extractionScope. ${error}`);
+                }
+            }
         }
         catch (error) {
             if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
@@ -104,7 +185,12 @@ class State {
                 await this.postState(initialAdapterState);
             }
             else {
-                console.error('Failed to init state.', (0, logger_1.serializeError)(error));
+                const errorMessage = `Failed to init state. ${(0, logger_1.serializeError)(error)}`;
+                console.error(errorMessage);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                    payload: { message: errorMessage },
+                });
                 process.exit(1);
             }
         }
@@ -121,7 +207,12 @@ class State {
             stringifiedState = JSON.stringify(this.state);
         }
         catch (error) {
-            console.error('Failed to stringify state.', (0, logger_1.serializeError)(error));
+            const errorMessage = `Failed to stringify state. ${(0, logger_1.serializeError)(error)}`;
+            console.error(errorMessage);
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                payload: { message: errorMessage },
+            });
             process.exit(1);
         }
         try {
@@ -139,7 +230,12 @@ class State {
             console.log('State updated successfully to', (0, logger_1.getPrintableState)(this.state));
         }
         catch (error) {
-            console.error('Failed to update the state.', (0, logger_1.serializeError)(error));
+            const errorMessage = `Failed to update the state. ${(0, logger_1.serializeError)(error)}`;
+            console.error(errorMessage);
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                payload: { message: errorMessage },
+            });
             process.exit(1);
         }
     }
@@ -148,7 +244,7 @@ class State {
      * @return  The raw state data from API
      */
     async fetchState() {
-        var _a;
+        var _a, _b;
         console.log(`Fetching state with sync unit id ${this.syncUnitId} and request id ${this.requestId}.`);
         const url = this.workerUrl + '.get';
         const response = await axios_client_internal_1.axiosClient.get(url, {
@@ -160,7 +256,10 @@ class State {
                 request_id: this.requestId,
             },
         });
-        return (_a = response.data) === null || _a === void 0 ? void 0 : _a.state;
+        return {
+            state: (_a = response.data) === null || _a === void 0 ? void 0 : _a.state,
+            objects: (_b = response.data) === null || _b === void 0 ? void 0 : _b.objects,
+        };
     }
 }
 exports.State = State;

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 state_1 = require("./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(state_1.State.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(state_1.State.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, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(state.state.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
+        expect(state.state.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, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert: pending values are overwritten with fresh resolution, not stale values
+        expect(state.state.pendingWorkersOldest).toBe('1970-01-01T00:00:00.000Z');
+        expect(state.state.pendingWorkersNewest).toBe(FIXED_NOW);
+        expect(state.state.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, state_1.createAdapterState)({
+            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.state.pendingWorkersOldest).toBe(pendingOldest);
+        expect(state.state.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, state_1.createAdapterState)({
+            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, state_1.createAdapterState)({
+            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,77 @@
+"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 state_1 = require("./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(state_1.State.prototype, 'postState');
+        fetchStateSpy = jest.spyOn(state_1.State.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, state_1.createAdapterState)({
+            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 state, preserving the original fields
+        expect(typeof body.state).toBe('string');
+        const parsed = JSON.parse(body.state);
+        expect(parsed.foo).toBe('bar');
+        expect(parsed.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, state_1.createAdapterState)({
+            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();
+    });
+});