@devrev/ts-adaas 1.9.0-beta.0 → 1.9.0

package/dist/http/axios-client-internal.test.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const axios_client_internal_1 = require("./axios-client-internal");
+describe('Internal Axios Client', () => {
+    let mockAdapter;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'warn').mockImplementation(() => { });
+        mockAdapter = new axios_mock_adapter_1.default(axios_client_internal_1.axiosClient);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        mockAdapter.restore();
+    });
+    it('should not retry on 200 response', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const responseData = { id: 1, title: 'test title' };
+        mockAdapter.onGet(testUrl).reply(200, responseData);
+        // Act
+        await axios_client_internal_1.axiosClient.get(testUrl);
+        // Assert
+        expect(mockAdapter.history.get).toHaveLength(1);
+    });
+    it('should not retry when response is 400', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Bad Request' };
+        mockAdapter.onGet(testUrl).reply(400, errorData);
+        // Act
+        await expect(axios_client_internal_1.axiosClient.get(testUrl)).rejects.toMatchObject({
+            response: { status: 400 },
+        });
+        // Assert
+        expect(mockAdapter.history.get).toHaveLength(1);
+    });
+    // TODO: This test is working as expected, but it takes too long to run. Not
+    // sure if it is good idea to have it.
+    // it('should retry on 500 response', async () => {
+    //   // Arrange
+    //   const testUrl = '/test-endpoint';
+    //   mockAdapter.onGet(testUrl).reply(500);
+    //   // Act & Assert
+    //   await expect(axiosClient.get(testUrl)).rejects.toMatchObject({
+    //     response: { status: 500 },
+    //   });
+    //   // Assert
+    //   expect(mockAdapter.history.get).toHaveLength(6);
+    // }, 100000);
+    it('should retry 2 times when response is 500 and then succeed third time when response is 200', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const successData = { message: 'success after 2 retries' };
+        mockAdapter
+            .onGet(testUrl)
+            .replyOnce(500)
+            .onGet(testUrl)
+            .replyOnce(500)
+            .onGet(testUrl)
+            .reply(200, successData);
+        // Act
+        const response = await axios_client_internal_1.axiosClient.get(testUrl);
+        // Assert
+        expect(response.status).toBe(200);
+        expect(response.data).toEqual(successData);
+        expect(mockAdapter.history.get).toHaveLength(3); // 1 initial + 2 retries
+    }, 10000); // Allow time for 2 retries
+    it('should retry once after 2 seconds when response is 429 and Retry-After header is valid value', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        const successData = { message: 'success after rate limit retry' };
+        mockAdapter
+            .onGet(testUrl)
+            .replyOnce(429, errorData, {
+            'Retry-After': '2',
+        })
+            .onGet(testUrl)
+            .reply(200, successData);
+        // Act
+        const response = await axios_client_internal_1.axiosClient.get(testUrl);
+        // Assert
+        expect(response.status).toBe(200);
+        expect(response.data).toEqual(successData);
+        expect(mockAdapter.history.get).toHaveLength(2); // 1 initial + 1 retry
+    });
+    it('should retry once after 2 seconds and measure time between retries when response is 429 and Retry-After header is valid value', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        const successData = { message: 'success after rate limit retry' };
+        const retryAfterSeconds = 2;
+        mockAdapter
+            .onGet(testUrl)
+            .replyOnce(429, errorData, {
+            'Retry-After': retryAfterSeconds.toString(),
+        })
+            .onGet(testUrl)
+            .reply(200, successData);
+        // Act
+        const startTime = Date.now();
+        const response = await axios_client_internal_1.axiosClient.get(testUrl);
+        const endTime = Date.now();
+        const actualWaitTime = endTime - startTime;
+        // Assert
+        expect(response.status).toBe(200);
+        expect(response.data).toEqual(successData);
+        expect(mockAdapter.history.get).toHaveLength(2); // 1 initial + 1 retry
+        const expectedWaitTime = retryAfterSeconds * 1000;
+        expect(actualWaitTime).toBeGreaterThanOrEqual(expectedWaitTime - 100);
+        expect(actualWaitTime).toBeLessThan(expectedWaitTime + 1000); // Allow up to 1s extra for processing
+    });
+    it('should retry when response is 429 and Retry-After header is lowercase', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        const successData = { message: 'success after rate limit retry' };
+        mockAdapter
+            .onGet(testUrl)
+            .replyOnce(429, errorData, { 'retry-after': '2' })
+            .onGet(testUrl)
+            .reply(200, successData);
+        // Act
+        const response = await axios_client_internal_1.axiosClient.get(testUrl);
+        // Assert
+        expect(response.status).toBe(200);
+        expect(response.data).toEqual(successData);
+        expect(mockAdapter.history.get).toHaveLength(2); // 1 initial + 1 retry
+    });
+    it('[edge] should not retry when response is 429 and there is no Retry-After header', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        mockAdapter.onGet(testUrl).reply(429, errorData);
+        // Act
+        await expect(axios_client_internal_1.axiosClient.get(testUrl)).rejects.toMatchObject({
+            response: { status: 429 },
+        });
+        // Assert
+        expect(mockAdapter.history.get).toHaveLength(1);
+    });
+    it('[edge] should retry when response is 429 and Retry-After header is 0', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        const successData = { message: 'success after rate limit retry' };
+        mockAdapter
+            .onGet(testUrl)
+            .replyOnce(429, errorData, { 'Retry-After': '0' })
+            .onGet(testUrl)
+            .reply(200, successData);
+        // Act
+        const response = await axios_client_internal_1.axiosClient.get(testUrl);
+        // Assert
+        expect(response.status).toBe(200);
+        expect(response.data).toEqual(successData);
+        expect(mockAdapter.history.get).toHaveLength(2); // 1 initial + 1 retry
+    });
+    it('[edge] should not retry when response is 429 and Retry-After header is negative', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        mockAdapter.onGet(testUrl).reply(429, errorData, { 'Retry-After': '-1' });
+        // Act
+        await expect(axios_client_internal_1.axiosClient.get(testUrl)).rejects.toMatchObject({
+            response: { status: 429 },
+        });
+        // Assert
+        expect(mockAdapter.history.get).toHaveLength(1);
+    });
+    it('[edge] should not retry when response is 429 and Retry-After header is invalid value', async () => {
+        // Arrange
+        const testUrl = '/test-endpoint';
+        const errorData = { error: 'Too Many Requests' };
+        mockAdapter
+            .onGet(testUrl)
+            .reply(429, errorData, { 'Retry-After': 'invalid' });
+        // Act
+        await expect(axios_client_internal_1.axiosClient.get(testUrl)).rejects.toMatchObject({
+            response: { status: 429 },
+        });
+        // Assert
+        expect(mockAdapter.history.get).toHaveLength(1);
+    });
+});

package/dist/logger/logger.js

@@ -14,7 +14,7 @@ class Logger extends node_console_1.Console {
     constructor({ event, options }) {
         super(process.stdout, process.stderr);
         this.options = options;
-        this.tags = Object.assign(Object.assign({}, event.payload.event_context), { dev_oid: event.payload.event_context.dev_org });
+        this.tags = Object.assign(Object.assign({}, event.payload.event_context), { dev_oid: event.payload.event_context.dev_oid });
     }
     valueToString(value) {
         if (typeof value === 'string') {

package/dist/logger/logger.test.js

@@ -14,7 +14,7 @@ jest.mock('node:worker_threads', () => ({
     isMainThread: true,
     parentPort: null,
 }));
-describe('Logger', () => {
+describe(logger_1.Logger.name, () => {
     let mockEvent;
     let mockOptions;
     beforeEach(() => {
@@ -50,7 +50,7 @@ describe('Logger', () => {
             const logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
             // Access private property for testing
             const tags = logger.tags;
-            expect(tags).toEqual(Object.assign(Object.assign({}, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org }));
+            expect(tags).toEqual(Object.assign(Object.assign({}, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid }));
         });
     });
     describe('production logging', () => {
@@ -62,7 +62,7 @@ describe('Logger', () => {
         it('should log single string message without backslashes', () => {
             const message = 'Worker is online. Started processing the task.';
             logger.info(message);
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid })));
         });
         it('should log single object message with JSON stringify', () => {
             const data = { id: 123, name: 'test' };
@@ -71,7 +71,7 @@ describe('Logger', () => {
                 compact: false,
                 depth: Infinity,
             });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: expectedMessage }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid })));
         });
         it('should log multiple arguments joined with space', () => {
             const text = 'Successfully fetched';
@@ -81,7 +81,7 @@ describe('Logger', () => {
                 compact: false,
                 depth: Infinity,
             });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text} ${expectedDataMessage}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid })));
         });
         it('should handle mixed string and object arguments', () => {
             const text1 = 'Processing';
@@ -92,7 +92,7 @@ describe('Logger', () => {
                 compact: false,
                 depth: Infinity,
             });
-            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_org })));
+            expect(mockConsoleInfo).toHaveBeenCalledWith(JSON.stringify(Object.assign(Object.assign({ message: `${text1} ${expectedDataMessage} ${text2}` }, mockEvent.payload.event_context), { dev_oid: mockEvent.payload.event_context.dev_oid })));
         });
     });
     describe('local development logging', () => {
@@ -137,25 +137,25 @@ describe('Logger', () => {
             mockOptions.isLocalDevelopment = false;
             logger = new logger_1.Logger({ event: mockEvent, options: mockOptions });
         });
-        it('should handle empty string message', () => {
+        it('[edge] should handle empty string message', () => {
             logger.info('');
             expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
             const callArgs = mockConsoleInfo.mock.calls[0][0];
             const logObject = JSON.parse(callArgs);
             expect(logObject.message).toBe('');
-            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_org);
+            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
             expect(logObject.request_id).toBe(mockEvent.payload.event_context.request_id);
         });
-        it('should handle null and undefined values', () => {
+        it('[edge] should handle null and undefined values', () => {
             logger.info('test', null, undefined);
             expect(mockConsoleInfo).toHaveBeenCalledTimes(1);
             const callArgs = mockConsoleInfo.mock.calls[0][0];
             const logObject = JSON.parse(callArgs);
             // inspect shows 'null' and 'undefined' as strings
             expect(logObject.message).toBe('test null undefined');
-            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_org);
+            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
         });
-        it('should handle complex nested objects', () => {
+        it('[edge] should handle complex nested objects', () => {
             const complexObject = {
                 level1: {
                     level2: {
@@ -174,7 +174,7 @@ describe('Logger', () => {
                 depth: Infinity,
             });
             expect(logObject.message).toBe(expectedMessage);
-            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_org);
+            expect(logObject.dev_oid).toBe(mockEvent.payload.event_context.dev_oid);
             expect(typeof logObject.callback_url).toBe('string');
         });
     });

package/dist/mappers/mappers.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mappers = void 0;
-const axios_client_1 = require("../http/axios-client");
+const axios_client_internal_1 = require("../http/axios-client-internal");
 class Mappers {
     constructor({ event }) {
         this.devrevApiEndpoint = event.execution_metadata.devrev_endpoint;
@@ -9,7 +9,7 @@ class Mappers {
     }
     async getByTargetId(params) {
         const { sync_unit, target } = params;
-        return axios_client_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
+        return axios_client_internal_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
             headers: {
                 Authorization: this.devrevApiToken,
             },
@@ -17,14 +17,14 @@ class Mappers {
         });
     }
     async create(params) {
-        return axios_client_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.create`, params, {
+        return axios_client_internal_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.create`, params, {
             headers: {
                 Authorization: this.devrevApiToken,
             },
         });
     }
     async update(params) {
-        return axios_client_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.update`, params, {
+        return axios_client_internal_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.update`, params, {
             headers: {
                 Authorization: this.devrevApiToken,
             },

package/dist/repo/repo.test.js

@@ -5,7 +5,7 @@ const test_helpers_1 = require("../tests/test-helpers");
 const types_1 = require("../types");
 const repo_1 = require("./repo");
 jest.mock('../tests/test-helpers', () => (Object.assign(Object.assign({}, jest.requireActual('../tests/test-helpers')), { normalizeItem: jest.fn() })));
-describe('Repo class push method', () => {
+describe(repo_1.Repo.name, () => {
     let repo;
     let normalize;
     beforeEach(() => {
@@ -20,18 +20,14 @@ describe('Repo class push method', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('should not push items if items array is empty', async () => {
-        await repo.push([]);
-        expect(repo.getItems()).toEqual([]);
-    });
-    it('should normalize and push 10 items if array is not empty', async () => {
+    it('should normalize and push items when array contains items', async () => {
         const items = (0, test_helpers_1.createItems)(10);
         await repo.push(items);
         expect(normalize).toHaveBeenCalledTimes(10);
         const normalizedItems = items.map((item) => (0, test_helpers_1.normalizeItem)(item));
         expect(repo.getItems()).toEqual(normalizedItems);
     });
-    it('should not normalize items if normalize function is not provided', async () => {
+    it('should not normalize items when normalize function is not provided', async () => {
         repo = new repo_1.Repo({
             event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
             itemType: 'test_item_type',
@@ -42,46 +38,56 @@ describe('Repo class push method', () => {
         await repo.push(items);
         expect(normalize).not.toHaveBeenCalled();
     });
-    describe('should not normalize items if type is "external_domain_metadata" or "ssor_attachment"', () => {
-        it('item type: external_domain_metadata', async () => {
-            repo = new repo_1.Repo({
-                event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
-                itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.EXTERNAL_DOMAIN_METADATA,
-                normalize,
-                onUpload: jest.fn(),
-                options: {},
-            });
-            const items = (0, test_helpers_1.createItems)(10);
-            await repo.push(items);
-            expect(normalize).not.toHaveBeenCalled();
+    it('[edge] should not push items when items array is empty', async () => {
+        await repo.push([]);
+        expect(repo.getItems()).toEqual([]);
+    });
+    it('should not normalize items when item type is external_domain_metadata', async () => {
+        repo = new repo_1.Repo({
+            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.EXTERNAL_DOMAIN_METADATA,
+            normalize,
+            onUpload: jest.fn(),
+            options: {},
         });
-        it('item type: ssor_attachment', async () => {
-            repo = new repo_1.Repo({
-                event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
-                itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.SSOR_ATTACHMENT,
-                normalize,
-                onUpload: jest.fn(),
-                options: {},
-            });
-            const items = (0, test_helpers_1.createItems)(10);
-            await repo.push(items);
-            expect(normalize).not.toHaveBeenCalled();
+        const items = (0, test_helpers_1.createItems)(10);
+        await repo.push(items);
+        expect(normalize).not.toHaveBeenCalled();
+    });
+    it('should not normalize items when item type is ssor_attachment', async () => {
+        repo = new repo_1.Repo({
+            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            itemType: constants_1.AIRDROP_DEFAULT_ITEM_TYPES.SSOR_ATTACHMENT,
+            normalize,
+            onUpload: jest.fn(),
+            options: {},
         });
+        const items = (0, test_helpers_1.createItems)(10);
+        await repo.push(items);
+        expect(normalize).not.toHaveBeenCalled();
     });
     it('should leave 5 items in the items array after pushing 2005 items with batch size of 2000', async () => {
         const items = (0, test_helpers_1.createItems)(2005);
         await repo.push(items);
         expect(repo.getItems().length).toBe(5);
     });
-    it('should upload 2 batches of 2000 and leave 5 items in the items array after pushing 4005 items with batch size of 2000', async () => {
-        const uploadSpy = jest.spyOn(repo, 'upload');
+    it('should normalize all items when pushing 4005 items with batch size of 2000', async () => {
         const items = (0, test_helpers_1.createItems)(4005);
         await repo.push(items);
         expect(normalize).toHaveBeenCalledTimes(4005);
-        expect(repo.getItems().length).toBe(5);
-        expect(uploadSpy).toHaveBeenCalledTimes(2); // Check that upload was called twice
+    });
+    it('should upload 2 batches when pushing 4005 items with batch size of 2000', async () => {
+        const uploadSpy = jest.spyOn(repo, 'upload');
+        const items = (0, test_helpers_1.createItems)(4005);
+        await repo.push(items);
+        expect(uploadSpy).toHaveBeenCalledTimes(2);
         uploadSpy.mockRestore();
     });
+    it('should leave 5 items in array after pushing 4005 items with batch size of 2000', async () => {
+        const items = (0, test_helpers_1.createItems)(4005);
+        await repo.push(items);
+        expect(repo.getItems().length).toBe(5);
+    });
     describe('should take batch size into account', () => {
         beforeEach(() => {
             repo = new repo_1.Repo({
@@ -104,14 +110,22 @@ describe('Repo class push method', () => {
             await repo.push(items);
             expect(repo.getItems().length).toBe(5);
         });
-        it('should upload 4 batches of 50 and leave 5 items in the items array after pushing 205 items with batch size of 50', async () => {
-            const uploadSpy = jest.spyOn(repo, 'upload');
+        it('should normalize all items when pushing 205 items with batch size of 50', async () => {
             const items = (0, test_helpers_1.createItems)(205);
             await repo.push(items);
             expect(normalize).toHaveBeenCalledTimes(205);
-            expect(repo.getItems().length).toBe(5);
+        });
+        it('should upload 4 batches when pushing 205 items with batch size of 50', async () => {
+            const uploadSpy = jest.spyOn(repo, 'upload');
+            const items = (0, test_helpers_1.createItems)(205);
+            await repo.push(items);
             expect(uploadSpy).toHaveBeenCalledTimes(4);
             uploadSpy.mockRestore();
         });
+        it('should leave 5 items in array after pushing 205 items with batch size of 50', async () => {
+            const items = (0, test_helpers_1.createItems)(205);
+            await repo.push(items);
+            expect(repo.getItems().length).toBe(5);
+        });
     });
 });

package/dist/state/state.d.ts

@@ -1,25 +1,29 @@
-import { ErrorRecord } from '../types/common';
 import { AdapterState, StateInterface } from './state.interfaces';
 export declare function createAdapterState<ConnectorState>({ event, initialState, initialDomainMapping, options, }: StateInterface<ConnectorState>): Promise<State<ConnectorState>>;
 export declare class State<ConnectorState> {
     private _state;
     private initialSdkState;
-    private event;
     private workerUrl;
     private devrevToken;
+    private syncUnitId;
+    private requestId;
     constructor({ event, initialState }: StateInterface<ConnectorState>);
     get state(): AdapterState<ConnectorState>;
     set state(value: AdapterState<ConnectorState>);
     /**
-     *  Updates the state of the adapter.
-     *
+     * Initializes the state for this adapter instance by fetching from API
+     * or creating an initial state if none exists (404).
+     * @param initialState The initial connector state provided by the spawn function
+     */
+    init(initialState: ConnectorState): Promise<void>;
+    /**
+     *  Updates the state of the adapter by posting to API.
      * @param {object} state - The state to be updated
      */
     postState(state?: AdapterState<ConnectorState>): Promise<void>;
     /**
-     *  Fetches the state of the adapter.
-     *
-     * @return  The state of the adapter
+     *  Fetches the state of the adapter from API.
+     * @return  The raw state data from API
      */
-    fetchState(initialState: ConnectorState): Promise<AdapterState<ConnectorState> | ErrorRecord>;
+    fetchState(): Promise<string>;
 }

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

@@ -30,3 +30,21 @@ export interface StateInterface<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[];
+    };
+};

package/dist/state/state.interfaces.js

@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadingSdkState = exports.extractionSdkState = void 0;
+exports.extractionSdkState = {
+    lastSyncStarted: '',
+    lastSuccessfulSyncStarted: '',
+    snapInVersionId: '',
+    toDevRev: {
+        attachmentsMetadata: {
+            artifactIds: [],
+            lastProcessed: 0,
+            lastProcessedAttachmentsIdsList: [],
+        },
+    },
+};
+exports.loadingSdkState = {
+    snapInVersionId: '',
+    fromDevRev: {
+        filesToLoad: [],
+    },
+};