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

package/dist/state/state.js

@@ -1,42 +1,51 @@
 "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_client_1 = require("../http/axios-client");
+const axios_1 = __importDefault(require("axios"));
+const axios_client_internal_1 = require("../http/axios-client-internal");
 const extraction_1 = require("../types/extraction");
+const common_1 = require("../types/common");
 const constants_1 = require("../common/constants");
 const logger_1 = require("../logger/logger");
 const install_initial_domain_mapping_1 = require("../common/install-initial-domain-mapping");
 const helpers_1 = require("../common/helpers");
+const state_interfaces_1 = require("./state.interfaces");
 async function createAdapterState({ event, initialState, initialDomainMapping, options, }) {
-    const newInitialState = structuredClone(initialState);
+    // Deep clone the initial state to avoid mutating the original state
+    const deepCloneInitialState = structuredClone(initialState);
     const as = new State({
         event,
-        initialState: newInitialState,
+        initialState: deepCloneInitialState,
         initialDomainMapping,
         options,
     });
     if (!constants_1.STATELESS_EVENT_TYPES.includes(event.payload.event_type)) {
-        await as.fetchState(newInitialState);
+        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.`);
+            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 {
-                    console.warn('No initial domain mapping was passed to spawn function. Skipping initial domain mapping installation.');
+                    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 ExtractionDataStart
@@ -51,29 +60,14 @@ async function createAdapterState({ event, initialState, initialDomainMapping, o
 class State {
     constructor({ event, initialState }) {
         this.initialSdkState =
-            (0, helpers_1.getSyncDirection)({ event }) === extraction_1.SyncMode.LOADING
-                ? {
-                    snapInVersionId: '',
-                    fromDevRev: {
-                        filesToLoad: [],
-                    },
-                }
-                : {
-                    lastSyncStarted: '',
-                    lastSuccessfulSyncStarted: '',
-                    snapInVersionId: '',
-                    toDevRev: {
-                        attachmentsMetadata: {
-                            artifactIds: [],
-                            lastProcessed: 0,
-                            lastProcessedAttachmentsIdsList: [],
-                        },
-                    },
-                };
+            (0, helpers_1.getSyncDirection)({ event }) === common_1.SyncMode.LOADING
+                ? state_interfaces_1.loadingSdkState
+                : state_interfaces_1.extractionSdkState;
         this._state = Object.assign(Object.assign({}, initialState), this.initialSdkState);
-        this.event = event;
         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;
@@ -82,24 +76,67 @@ class State {
         this._state = value;
     }
     /**
-     *  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
+     */
+    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.');
+            }
+            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 {
-            await axios_client_1.axiosClient.post(this.workerUrl + '.update', {
-                state: JSON.stringify(state || this.state),
+            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.event.payload.event_context.sync_unit_id,
-                    request_id: this.event.payload.event_context.uuid,
+                    sync_unit: this.syncUnitId,
+                    request_id: this.requestId,
                 },
             });
-            this.state = state || this.state;
             console.log('State updated successfully to', (0, logger_1.getPrintableState)(this.state));
         }
         catch (error) {
@@ -108,42 +145,23 @@ class State {
         }
     }
     /**
-     *  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
      */
-    async fetchState(initialState) {
+    async fetchState() {
         var _a;
-        console.log('Fetching state with sync unit id: ' +
-            this.event.payload.event_context.sync_unit_id +
-            '.');
-        try {
-            const response = await axios_client_1.axiosClient.get(this.workerUrl + '.get', {
-                headers: {
-                    Authorization: this.devrevToken,
-                },
-                params: {
-                    sync_unit: this.event.payload.event_context.sync_unit_id,
-                    request_id: this.event.payload.event_context.uuid,
-                },
-            });
-            this.state = JSON.parse(response.data.state);
-            console.log('State fetched successfully. Current state', (0, logger_1.getPrintableState)(this.state));
-            return this.state;
-        }
-        catch (error) {
-            if (axios_client_1.axios.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
-                const state = Object.assign(Object.assign({}, initialState), this.initialSdkState);
-                this.state = state;
-                console.log('State not found, returning initial state. Current state', (0, logger_1.getPrintableState)(this.state));
-                await this.postState(this.state);
-                return this.state;
-            }
-            else {
-                console.error('Failed to fetch state.', error);
-                process.exit(1);
-            }
-        }
+        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 @@
+export {};

package/dist/state/state.test.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const state_1 = require("./state");
+const extraction_1 = require("../types/extraction");
+const test_helpers_1 = require("../tests/test-helpers");
+const constants_1 = require("../common/constants");
+const state_interfaces_1 = require("./state.interfaces");
+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.ExtractionDataStart))('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.ExtractionDataStart, async () => {
+        // Arrange
+        const initialState = {
+            test: 'test',
+        };
+        const event = (0, test_helpers_1.createEvent)({
+            eventType: extraction_1.EventType.ExtractionDataStart,
+            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();
+    });
+});

package/dist/tests/test-helpers.js

@@ -10,17 +10,25 @@ function createEvent({ eventType, externalSyncUnits = [], progress, error, delay
     const defaultEventContext = {
         callback_url: 'test_callback_url',
         dev_org: 'test_dev_org',
+        dev_oid: 'test_dev_oid',
         dev_org_id: 'test_dev_org_id',
         dev_user: 'test_dev_user',
         dev_user_id: 'test_dev_user_id',
+        dev_uid: 'test_dev_uid',
+        event_type_adaas: 'test_event_type_adaas',
         external_sync_unit: 'test_external_sync_unit',
         external_sync_unit_id: 'test_external_sync_unit_id',
         external_sync_unit_name: 'test_external_sync_unit_name',
         external_system: 'test_external_system',
+        external_system_id: 'test_external_system_id',
+        external_system_name: 'test_external_system_name',
         external_system_type: 'test_external_system_type',
         import_slug: 'test_import_slug',
         mode: 'test_mode',
         request_id: 'test_request_id',
+        request_id_adaas: 'test_request_id_adaas',
+        run_id: 'test_run_id',
+        sequence_version: 'test_sequence_version',
         snap_in_slug: 'test_snap_in_slug',
         snap_in_version_id: 'test_snap_in_version_id',
         sync_run: 'test_sync_run',

package/dist/tests/timeout-handling/timeout-1.test.js

@@ -7,7 +7,7 @@ const extraction_1 = require("../../types/extraction");
 const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
-describe('timeout-1', () => {
+describe('timeout-1 extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/tests/timeout-handling/timeout-2.test.js

@@ -8,7 +8,7 @@ const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
 jest.setTimeout(15000);
-describe('timeout-2', () => {
+describe('timeout-2 extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/tests/timeout-handling/timeout-3a.test.js

@@ -8,7 +8,7 @@ const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
 jest.setTimeout(15000);
-describe('timeout-3a', () => {
+describe('timeout-3a extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/tests/timeout-handling/timeout-3b.test.js

@@ -8,7 +8,7 @@ const test_helpers_1 = require("../test-helpers");
 const extraction_2 = __importDefault(require("./extraction"));
 const mock_server_1 = require("../mock-server");
 jest.setTimeout(15000);
-describe('timeout-3b', () => {
+describe('timeout-3b extraction', () => {
     let mockServer;
     beforeAll(async () => {
         mockServer = new mock_server_1.MockServer(3001);

package/dist/types/common.d.ts

@@ -36,3 +36,14 @@ export interface InitialDomainMapping {
     starting_recipe_blueprint?: object;
     additional_mappings?: object;
 }
+/**
+ * SyncMode is an enum that defines the different modes of sync that can be used by the external extractor.
+ * It can be either INITIAL, INCREMENTAL or LOADING. INITIAL mode is used for
+ * the first/initial import, while INCREMENTAL mode is used for doing syncs. LOADING mode is used for
+ * loading data from DevRev to the external system.
+ */
+export declare enum SyncMode {
+    INITIAL = "INITIAL",
+    INCREMENTAL = "INCREMENTAL",
+    LOADING = "LOADING"
+}

package/dist/types/common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorLevel = void 0;
+exports.SyncMode = exports.ErrorLevel = void 0;
 /**
  * ErrorLevel is an enum that represents the level of an error.
  * @deprecated
@@ -11,3 +11,15 @@ var ErrorLevel;
     ErrorLevel["Error"] = "ERROR";
     ErrorLevel["Info"] = "INFO";
 })(ErrorLevel || (exports.ErrorLevel = ErrorLevel = {}));
+/**
+ * SyncMode is an enum that defines the different modes of sync that can be used by the external extractor.
+ * It can be either INITIAL, INCREMENTAL or LOADING. INITIAL mode is used for
+ * the first/initial import, while INCREMENTAL mode is used for doing syncs. LOADING mode is used for
+ * loading data from DevRev to the external system.
+ */
+var SyncMode;
+(function (SyncMode) {
+    SyncMode["INITIAL"] = "INITIAL";
+    SyncMode["INCREMENTAL"] = "INCREMENTAL";
+    SyncMode["LOADING"] = "LOADING";
+})(SyncMode || (exports.SyncMode = SyncMode = {}));

package/dist/types/extraction.d.ts

@@ -57,15 +57,6 @@ export declare enum ExtractionMode {
     INITIAL = "INITIAL",
     INCREMENTAL = "INCREMENTAL"
 }
-/**
- * ExtractionMode is an enum that defines the different modes of extraction that can be used by the external extractor.
- * It can be either INITIAL or INCREMENTAL. INITIAL mode is used for the first/initial import, while INCREMENTAL mode is used for doing syncs.
- */
-export declare enum SyncMode {
-    INITIAL = "INITIAL",
-    INCREMENTAL = "INCREMENTAL",
-    LOADING = "LOADING"
-}
 /**
  * ExternalSyncUnit is an interface that defines the structure of an external sync unit (repos, projects, ...) that can be extracted.
  * It must contain an ID, a name, and a description. It can also contain the number of items in the external sync unit.
@@ -125,32 +116,64 @@ export interface EventContextOut {
  */
 export interface EventContext {
     callback_url: string;
+    /**
+     * @deprecated dev_org is deprecated and should not be used. Use dev_oid instead.
+     */
     dev_org: string;
+    dev_oid: string;
     dev_org_id: string;
+    /**
+     * @deprecated dev_user is deprecated and should not be used. Use dev_uid instead.
+     */
     dev_user: string;
+    /**
+     * @deprecated dev_user_id is deprecated and should not be used. Use dev_uid instead.
+     */
     dev_user_id: string;
+    dev_uid: string;
+    event_type_adaas: string;
+    /**
+     * @deprecated external_sync_unit is deprecated and should not be used. Use external_sync_unit_id instead.
+     */
     external_sync_unit: string;
     external_sync_unit_id: string;
     external_sync_unit_name: string;
+    /**
+     * @deprecated external_system is deprecated and should not be used. Use external_system_id instead.
+     */
     external_system: string;
+    external_system_id: string;
+    external_system_name: string;
     external_system_type: string;
     extract_from?: string;
     import_slug: string;
     initial_sync_scope?: InitialSyncScope;
     mode: string;
     request_id: string;
+    request_id_adaas: string;
     /**
      * @deprecated reset_extraction is deprecated and should not be used. Use reset_extract_from instead.
      */
     reset_extraction?: boolean;
     reset_extract_from?: boolean;
+    run_id: string;
+    sequence_version: string;
     snap_in_slug: string;
     snap_in_version_id: string;
+    /**
+     * @deprecated sync_run is deprecated and should not be used. Use run_id instead.
+     */
     sync_run: string;
+    /**
+     * @deprecated sync_run_id is deprecated and should not be used. Use run_id instead.
+     */
     sync_run_id: string;
     sync_tier: string;
     sync_unit: DonV2;
     sync_unit_id: string;
+    /**
+     * @deprecated uuid is deprecated and should not be used. Use request_id_adaas instead.
+     */
     uuid: string;
     worker_data_url: string;
 }

package/dist/types/extraction.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InitialSyncScope = exports.SyncMode = exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
+exports.InitialSyncScope = exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
 /**
  * EventType is an enum that defines the different types of events that can be sent to the external extractor from ADaaS.
  * The external extractor can use these events to know what to do next in the extraction process.
@@ -60,16 +60,6 @@ var ExtractionMode;
     ExtractionMode["INITIAL"] = "INITIAL";
     ExtractionMode["INCREMENTAL"] = "INCREMENTAL";
 })(ExtractionMode || (exports.ExtractionMode = ExtractionMode = {}));
-/**
- * ExtractionMode is an enum that defines the different modes of extraction that can be used by the external extractor.
- * It can be either INITIAL or INCREMENTAL. INITIAL mode is used for the first/initial import, while INCREMENTAL mode is used for doing syncs.
- */
-var SyncMode;
-(function (SyncMode) {
-    SyncMode["INITIAL"] = "INITIAL";
-    SyncMode["INCREMENTAL"] = "INCREMENTAL";
-    SyncMode["LOADING"] = "LOADING";
-})(SyncMode || (exports.SyncMode = SyncMode = {}));
 /**
  * InitialSyncScope is an enum that defines the different scopes of initial sync that can be used by the external extractor.
  */