@devrev/airsync-sdk 2.0.0-beta.0

package/dist/repo/repo.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../common/constants");
+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_1.Repo.name, () => {
+    let repo;
+    let normalize;
+    beforeEach(() => {
+        normalize = jest.fn();
+        repo = new repo_1.Repo({
+            event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+            itemType: 'test_item_type',
+            normalize,
+            onUpload: jest.fn(),
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    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 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',
+            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: {},
+        });
+        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 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);
+    });
+    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({
+                event: (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart }),
+                itemType: 'test_item_type',
+                normalize,
+                onUpload: jest.fn(),
+                options: {
+                    batchSize: 50,
+                },
+            });
+        });
+        it('should empty the items array after pushing 50 items with batch size of 50', async () => {
+            const items = (0, test_helpers_1.createItems)(50);
+            await repo.push(items);
+            expect(repo.getItems()).toEqual([]);
+        });
+        it('should leave 5 items in the items 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);
+        });
+        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);
+        });
+        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

@@ -0,0 +1,30 @@
+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 workerUrl;
+    private devrevToken;
+    private syncUnitId;
+    private requestId;
+    constructor({ event, initialState }: StateInterface<ConnectorState>);
+    get state(): AdapterState<ConnectorState>;
+    set state(value: AdapterState<ConnectorState>);
+    /**
+     * 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 from API.
+     * @return  The raw state data from API
+     */
+    fetchState(): Promise<string>;
+}
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state/state.ts"],"names":[],"mappings":"AASA,OAAO,EACL,YAAY,EAIZ,cAAc,EACf,MAAM,oBAAoB,CAAC;AAE5B,wBAAsB,kBAAkB,CAAC,cAAc,EAAE,EACvD,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,GACR,EAAE,cAAc,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CA0DjE;AAED,qBAAa,KAAK,CAAC,cAAc;IAC/B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;gBAEd,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,cAAc,CAAC,cAAc,CAAC;IAenE,IAAI,KAAK,IAAI,YAAY,CAAC,cAAc,CAAC,CAExC;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,YAAY,CAAC,cAAc,CAAC,EAE5C;IAED;;;;OAIG;IACG,IAAI,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCvD;;;OAGG;IACG,SAAS,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,cAAc,CAAC;IAuCpD;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;CAkBpC"}

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

@@ -0,0 +1,51 @@
+import { InitialDomainMapping } from '../types/common';
+import { AirdropEvent } from '../types/extraction';
+import { FileToLoad } from '../types/loading';
+import { WorkerAdapterOptions } from '../types/workers';
+export interface SdkState {
+    lastSyncStarted?: string;
+    lastSuccessfulSyncStarted?: string;
+    toDevRev?: ToDevRev;
+    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.
+ */
+export type AdapterState<ConnectorState> = ConnectorState & SdkState;
+export interface ToDevRev {
+    attachmentsMetadata: {
+        artifactIds: string[];
+        lastProcessed: number;
+        lastProcessedAttachmentsIdsList?: string[];
+    };
+}
+export interface FromDevRev {
+    filesToLoad: FileToLoad[];
+}
+export interface StateInterface<ConnectorState> {
+    event: AirdropEvent;
+    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[];
+    };
+};
+//# sourceMappingURL=state.interfaces.d.ts.map

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

@@ -0,0 +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,MAAM,EAAE,CAAC;KAC5C,CAAC;CACH;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"}

package/dist/state/state.interfaces.js

@@ -0,0 +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: [],
+    },
+};

package/dist/state/state.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+exports.createAdapterState = createAdapterState;
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../common/constants");
+const install_initial_domain_mapping_1 = require("../common/install-initial-domain-mapping");
+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 state_interfaces_1 = require("./state.interfaces");
+async function createAdapterState({ event, initialState, initialDomainMapping, options, }) {
+    // Deep clone the initial state to avoid mutating the original state
+    const deepCloneInitialState = structuredClone(initialState);
+    const as = new State({
+        event,
+        initialState: deepCloneInitialState,
+        initialDomainMapping,
+        options,
+    });
+    if (!constants_1.STATELESS_EVENT_TYPES.includes(event.payload.event_type)) {
+        await as.init(deepCloneInitialState);
+        // Check if IDM needs to be updated
+        const snapInVersionId = event.context.snap_in_version_id;
+        const hasSnapInVersionInState = 'snapInVersionId' in as.state;
+        const shouldUpdateIDM = !hasSnapInVersionInState || as.state.snapInVersionId !== snapInVersionId;
+        if (!shouldUpdateIDM) {
+            console.log(`Snap-in version in state matches the version in event context "${snapInVersionId}". Skipping initial domain mapping installation.`);
+        }
+        else {
+            try {
+                console.log(`Snap-in version in state "${as.state.snapInVersionId}" does not match the version in event context "${snapInVersionId}". Installing initial domain mapping.`);
+                if (initialDomainMapping) {
+                    await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(event, initialDomainMapping);
+                    as.state.snapInVersionId = snapInVersionId;
+                }
+                else {
+                    throw new Error('No initial domain mapping was passed to spawn function. Skipping initial domain mapping installation.');
+                }
+            }
+            catch (error) {
+                console.error('Error while installing initial domain mapping.', (0, logger_1.serializeError)(error));
+                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}.`);
+        }
+    }
+    return as;
+}
+class State {
+    constructor({ event, initialState }) {
+        this.initialSdkState =
+            event.payload.event_context.mode === common_1.SyncMode.LOADING
+                ? state_interfaces_1.loadingSdkState
+                : state_interfaces_1.extractionSdkState;
+        this._state = Object.assign(Object.assign({}, initialState), this.initialSdkState);
+        this.workerUrl = event.payload.event_context.worker_data_url;
+        this.devrevToken = event.context.secrets.service_account_token;
+        this.syncUnitId = event.payload.event_context.sync_unit_id;
+        this.requestId = event.payload.event_context.request_id_adaas;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        this._state = value;
+    }
+    /**
+     * 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
+     */
+    async init(initialState) {
+        var _a;
+        try {
+            const stringifiedState = await this.fetchState();
+            if (!stringifiedState) {
+                throw new Error('No state found in response.');
+            }
+            let parsedState;
+            try {
+                parsedState = JSON.parse(stringifiedState);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse state. ${error}`);
+            }
+            this.state = parsedState;
+            console.log('State fetched successfully. Current state', (0, logger_1.getPrintableState)(this.state));
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                console.log('State not found. Initializing state with initial state.');
+                const initialAdapterState = Object.assign(Object.assign({}, initialState), this.initialSdkState);
+                this.state = initialAdapterState;
+                await this.postState(initialAdapterState);
+            }
+            else {
+                console.error('Failed to init state.', (0, logger_1.serializeError)(error));
+                process.exit(1);
+            }
+        }
+    }
+    /**
+     *  Updates the state of the adapter by posting to API.
+     * @param {object} state - The state to be updated
+     */
+    async postState(state) {
+        const url = this.workerUrl + '.update';
+        this.state = state || this.state;
+        let stringifiedState;
+        try {
+            stringifiedState = JSON.stringify(this.state);
+        }
+        catch (error) {
+            console.error('Failed to stringify state.', (0, logger_1.serializeError)(error));
+            process.exit(1);
+        }
+        try {
+            await axios_client_internal_1.axiosClient.post(url, {
+                state: stringifiedState,
+            }, {
+                headers: {
+                    Authorization: this.devrevToken,
+                },
+                params: {
+                    sync_unit: this.syncUnitId,
+                    request_id: this.requestId,
+                },
+            });
+            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));
+            process.exit(1);
+        }
+    }
+    /**
+     *  Fetches the state of the adapter from API.
+     * @return  The raw state data from API
+     */
+    async fetchState() {
+        var _a;
+        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, {
+            headers: {
+                Authorization: this.devrevToken,
+            },
+            params: {
+                sync_unit: this.syncUnitId,
+                request_id: this.requestId,
+            },
+        });
+        return (_a = response.data) === null || _a === void 0 ? void 0 : _a.state;
+    }
+}
+exports.State = State;

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

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

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

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

package/dist/state/state.test.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../common/constants");
+const test_helpers_1 = require("../tests/test-helpers");
+const extraction_1 = require("../types/extraction");
+const state_1 = require("./state");
+const state_interfaces_1 = require("./state.interfaces");
+/* eslint-disable @typescript-eslint/no-require-imports */
+describe(state_1.State.name, () => {
+    let initSpy;
+    let postStateSpy;
+    let fetchStateSpy;
+    let installInitialDomainMappingSpy;
+    let processExitSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+        initSpy = jest.spyOn(state_1.State.prototype, 'init');
+        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');
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+    });
+    it.each(constants_1.STATELESS_EVENT_TYPES)('should not init, fetch, post or install IDM for stateless event type %s', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+        });
+        // Act
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(initSpy).not.toHaveBeenCalled();
+        expect(fetchStateSpy).not.toHaveBeenCalled();
+        expect(postStateSpy).not.toHaveBeenCalled();
+        expect(installInitialDomainMappingSpy).not.toHaveBeenCalled();
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching the state fails', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+        });
+        fetchStateSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 500 },
+        });
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        // Act & Assert
+        await expect((0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        })).rejects.toThrow('process.exit called');
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if parsing the state fails', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+        });
+        fetchStateSpy.mockResolvedValue('invalid-json');
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        // Act & Assert
+        await expect((0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        })).rejects.toThrow('process.exit called');
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching is successful but there is no state in the response', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+        });
+        fetchStateSpy.mockResolvedValue(null);
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        // Act & Assert
+        await expect((0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        })).rejects.toThrow('process.exit called');
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES.filter((eventType) => eventType !== extraction_1.EventType.StartExtractingData))('should call post state with full adapter state if fetching returns 404 for event type %s', async (eventType) => {
+        // Arrange
+        const initialState = {
+            test: 'test',
+        };
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+            contextOverrides: {
+                snap_in_version_id: '',
+            },
+        });
+        fetchStateSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        installInitialDomainMappingSpy.mockResolvedValue({
+            success: true,
+        });
+        postStateSpy.mockResolvedValue({
+            success: true,
+        });
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        // Act
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState,
+            initialDomainMapping: {},
+        });
+        const expectedState = Object.assign(Object.assign({}, initialState), state_interfaces_1.extractionSdkState);
+        expect(postStateSpy).toHaveBeenCalledWith(expectedState);
+    });
+    it(extraction_1.EventType.StartExtractingData, async () => {
+        // Arrange
+        const initialState = {
+            test: 'test',
+        };
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.StartExtractingData,
+            contextOverrides: {
+                snap_in_version_id: '',
+            },
+        });
+        fetchStateSpy.mockRejectedValue({
+            isAxiosError: true,
+            response: { status: 404 },
+        });
+        installInitialDomainMappingSpy.mockResolvedValue({
+            success: true,
+        });
+        postStateSpy.mockResolvedValue({
+            success: true,
+        });
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        // Act
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState,
+            initialDomainMapping: {},
+        });
+        // Assert
+        // Verify that post state is called with object that contains
+        // lastSyncStarted which is not empty string
+        expect(postStateSpy).toHaveBeenCalledWith(expect.objectContaining({
+            lastSyncStarted: expect.not.stringMatching(/^$/),
+        }));
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if initialDomainMapping is not provided for event type %s', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+        });
+        fetchStateSpy.mockResolvedValue(JSON.stringify({
+            test: 'test',
+        }));
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+        // Act & Assert
+        await expect((0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: undefined,
+        })).rejects.toThrow('process.exit called');
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should not install IDM if version matches for event type %s', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+            contextOverrides: {
+                snap_in_version_id: '1.0.0',
+            },
+        });
+        const stringifiedState = JSON.stringify({
+            test: 'test',
+            snapInVersionId: '1.0.0',
+        });
+        fetchStateSpy.mockResolvedValue(stringifiedState);
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        // Act & Assert
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(installInitialDomainMappingSpy).not.toHaveBeenCalled();
+    });
+    it.each(constants_1.STATEFUL_EVENT_TYPES)('should install IDM if version does not match for event type %s', async (eventType) => {
+        // Arrange
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: eventType,
+            contextOverrides: {
+                snap_in_version_id: '2.0.0',
+            },
+        });
+        const stringifiedState = JSON.stringify({
+            test: 'test',
+            snapInVersionId: '1.0.0',
+        });
+        fetchStateSpy.mockResolvedValue(stringifiedState);
+        installInitialDomainMappingSpy.mockResolvedValue({
+            success: true,
+        });
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        // Act
+        await (0, state_1.createAdapterState)({
+            event,
+            initialState: {},
+            initialDomainMapping: {},
+        });
+        // Assert
+        expect(installInitialDomainMappingSpy).toHaveBeenCalled();
+    });
+});