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

package/dist/multithreading/spawn/spawn.helpers.d.ts

@@ -1,5 +1,27 @@
 import { EventType, ExtractorEventType } from '../../types/extraction';
 import { LoaderEventType } from '../../types/loading';
+import { TaskStatus } from '../../types/workers';
+/**
+ * Resolves the outgoing event type the SDK should emit for a given incoming
+ * event type and the {@link TaskResult} status a worker returned.
+ *
+ * The mapping follows the per-phase contract documented on `TaskResult`:
+ * resumable phases (data/attachment extraction, data/attachment loading) honor
+ * every status (success -> *_DONE, progress -> *_PROGRESS, delay -> *_DELAYED,
+ * error -> *_ERROR); non-resumable phases (external sync units, metadata, state
+ * deletion) only have a done and an error event, so a `progress`/`delay` status
+ * there is illegal and is mapped to the phase's error event.
+ *
+ * @param eventType - The incoming event type that started this worker.
+ * @param status - The status the worker's task/onTimeout returned.
+ * @returns The outgoing extractor/loader event type to emit, plus whether the
+ * status was illegal for the phase (so the caller can attach a descriptive
+ * error message).
+ */
+export declare function getEventTypeForResult(eventType: EventType, status: TaskStatus): {
+    eventType: ExtractorEventType | LoaderEventType;
+    illegal: boolean;
+};
 /**
  * Gets the event type for the timeout error.
  * @param {EventType} eventType - The event type to get the timeout error event type for
@@ -14,8 +36,6 @@ export declare function getTimeoutErrorEventType(eventType: EventType): {
  * @returns {ExtractorEventType | LoaderEventType} The event type for the no script error
  */
 export declare function getNoScriptEventType(eventType: EventType): {
-    eventType: ExtractorEventType;
-} | {
-    eventType: LoaderEventType;
+    eventType: ExtractorEventType | LoaderEventType;
 };
 //# sourceMappingURL=spawn.helpers.d.ts.map

package/dist/multithreading/spawn/spawn.helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CA2EA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD"}
+{"version":3,"file":"spawn.helpers.d.ts","sourceRoot":"","sources":["../../../src/multithreading/spawn/spawn.helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,UAAU,GACjB;IACD,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;IAChD,OAAO,EAAE,OAAO,CAAC;CAClB,CAiCA;AAoHD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CA2EA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;eAwBhB,kBAAkB,GAAG,eAAe;EAG5E"}

package/dist/multithreading/spawn/spawn.helpers.js

@@ -1,9 +1,159 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventTypeForResult = getEventTypeForResult;
 exports.getTimeoutErrorEventType = getTimeoutErrorEventType;
 exports.getNoScriptEventType = getNoScriptEventType;
+const constants_1 = require("../../common/constants");
 const extraction_1 = require("../../types/extraction");
 const loading_1 = require("../../types/loading");
+/**
+ * Resolves the outgoing event type the SDK should emit for a given incoming
+ * event type and the {@link TaskResult} status a worker returned.
+ *
+ * The mapping follows the per-phase contract documented on `TaskResult`:
+ * resumable phases (data/attachment extraction, data/attachment loading) honor
+ * every status (success -> *_DONE, progress -> *_PROGRESS, delay -> *_DELAYED,
+ * error -> *_ERROR); non-resumable phases (external sync units, metadata, state
+ * deletion) only have a done and an error event, so a `progress`/`delay` status
+ * there is illegal and is mapped to the phase's error event.
+ *
+ * @param eventType - The incoming event type that started this worker.
+ * @param status - The status the worker's task/onTimeout returned.
+ * @returns The outgoing extractor/loader event type to emit, plus whether the
+ * status was illegal for the phase (so the caller can attach a descriptive
+ * error message).
+ */
+function getEventTypeForResult(eventType, status) {
+    const phase = EVENT_PHASE_MAP[eventType];
+    if (!phase) {
+        console.error('Event type not recognized in getEventTypeForResult function: ' +
+            eventType);
+        return {
+            eventType: constants_1.UNKNOWN_EVENT_TYPE,
+            illegal: true,
+        };
+    }
+    // Non-resumable phases only define done/error events.
+    if (!phase.resumable) {
+        if (status === 'success') {
+            return { eventType: phase.done, illegal: false };
+        }
+        // progress/delay are illegal here; collapse them (and error) to the error event.
+        return { eventType: phase.error, illegal: status !== 'error' };
+    }
+    switch (status) {
+        case 'success':
+            return { eventType: phase.done, illegal: false };
+        case 'progress':
+            return { eventType: phase.progress, illegal: false };
+        case 'delay':
+            return { eventType: phase.delayed, illegal: false };
+        case 'error':
+            return { eventType: phase.error, illegal: false };
+    }
+}
+/**
+ * Per-phase outgoing event types, keyed by the incoming {@link EventType}.
+ * `resumable` phases define progress/delayed events; non-resumable ones do not.
+ */
+const EVENT_PHASE_MAP = {
+    // External sync units (non-resumable)
+    [extraction_1.EventType.StartExtractingExternalSyncUnits]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionDone,
+        error: extraction_1.ExtractorEventType.ExternalSyncUnitExtractionError,
+    },
+    // Metadata (non-resumable)
+    [extraction_1.EventType.StartExtractingMetadata]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.MetadataExtractionDone,
+        error: extraction_1.ExtractorEventType.MetadataExtractionError,
+    },
+    // Data extraction (resumable)
+    [extraction_1.EventType.StartExtractingData]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.DataExtractionDone,
+        error: extraction_1.ExtractorEventType.DataExtractionError,
+        progress: extraction_1.ExtractorEventType.DataExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.DataExtractionDelayed,
+    },
+    [extraction_1.EventType.ContinueExtractingData]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.DataExtractionDone,
+        error: extraction_1.ExtractorEventType.DataExtractionError,
+        progress: extraction_1.ExtractorEventType.DataExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.DataExtractionDelayed,
+    },
+    // Extractor state deletion (non-resumable)
+    [extraction_1.EventType.StartDeletingExtractorState]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
+        error: extraction_1.ExtractorEventType.ExtractorStateDeletionError,
+    },
+    // Attachment extraction (resumable)
+    [extraction_1.EventType.StartExtractingAttachments]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.AttachmentExtractionDone,
+        error: extraction_1.ExtractorEventType.AttachmentExtractionError,
+        progress: extraction_1.ExtractorEventType.AttachmentExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
+    },
+    [extraction_1.EventType.ContinueExtractingAttachments]: {
+        resumable: true,
+        done: extraction_1.ExtractorEventType.AttachmentExtractionDone,
+        error: extraction_1.ExtractorEventType.AttachmentExtractionError,
+        progress: extraction_1.ExtractorEventType.AttachmentExtractionProgress,
+        delayed: extraction_1.ExtractorEventType.AttachmentExtractionDelayed,
+    },
+    // Extractor attachments state deletion (non-resumable)
+    [extraction_1.EventType.StartDeletingExtractorAttachmentsState]: {
+        resumable: false,
+        done: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
+        error: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionError,
+    },
+    // Data loading (resumable)
+    [extraction_1.EventType.StartLoadingData]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.DataLoadingDone,
+        error: loading_1.LoaderEventType.DataLoadingError,
+        progress: loading_1.LoaderEventType.DataLoadingProgress,
+        delayed: loading_1.LoaderEventType.DataLoadingDelayed,
+    },
+    [extraction_1.EventType.ContinueLoadingData]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.DataLoadingDone,
+        error: loading_1.LoaderEventType.DataLoadingError,
+        progress: loading_1.LoaderEventType.DataLoadingProgress,
+        delayed: loading_1.LoaderEventType.DataLoadingDelayed,
+    },
+    // Attachment loading (resumable)
+    [extraction_1.EventType.StartLoadingAttachments]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.AttachmentLoadingDone,
+        error: loading_1.LoaderEventType.AttachmentLoadingError,
+        progress: loading_1.LoaderEventType.AttachmentLoadingProgress,
+        delayed: loading_1.LoaderEventType.AttachmentLoadingDelayed,
+    },
+    [extraction_1.EventType.ContinueLoadingAttachments]: {
+        resumable: true,
+        done: loading_1.LoaderEventType.AttachmentLoadingDone,
+        error: loading_1.LoaderEventType.AttachmentLoadingError,
+        progress: loading_1.LoaderEventType.AttachmentLoadingProgress,
+        delayed: loading_1.LoaderEventType.AttachmentLoadingDelayed,
+    },
+    // Loader state deletion (non-resumable)
+    [extraction_1.EventType.StartDeletingLoaderState]: {
+        resumable: false,
+        done: loading_1.LoaderEventType.LoaderStateDeletionDone,
+        error: loading_1.LoaderEventType.LoaderStateDeletionError,
+    },
+    // Loader attachment state deletion (non-resumable)
+    [extraction_1.EventType.StartDeletingLoaderAttachmentState]: {
+        resumable: false,
+        done: loading_1.LoaderEventType.LoaderAttachmentStateDeletionDone,
+        error: loading_1.LoaderEventType.LoaderAttachmentStateDeletionError,
+    },
+};
 /**
  * Gets the event type for the timeout error.
  * @param {EventType} eventType - The event type to get the timeout error event type for
@@ -69,7 +219,7 @@ function getTimeoutErrorEventType(eventType) {
             console.error('Event type not recognized in getTimeoutErrorEventType function: ' +
                 eventType);
             return {
-                eventType: loading_1.LoaderEventType.UnknownEventType,
+                eventType: constants_1.UNKNOWN_EVENT_TYPE,
             };
     }
 }
@@ -100,7 +250,7 @@ function getNoScriptEventType(eventType) {
             console.error('Event type not recognized in getNoScriptEventType function: ' +
                 eventType);
             return {
-                eventType: loading_1.LoaderEventType.UnknownEventType,
+                eventType: constants_1.UNKNOWN_EVENT_TYPE,
             };
     }
 }

package/dist/multithreading/spawn/spawn.js

@@ -7,7 +7,7 @@ exports.Spawn = void 0;
 exports.spawn = spawn;
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
-const control_protocol_1 = require("../../common/control-protocol");
+const emit_1 = require("../emit");
 const helpers_2 = require("../../common/helpers");
 const logger_1 = require("../../logger/logger");
 const extraction_1 = require("../../types/extraction");
@@ -66,13 +66,13 @@ async function spawn({ event, initialState, initialDomainMapping, options, baseW
     if (options === null || options === void 0 ? void 0 : options.isLocalDevelopment) {
         console.log('Snap-in is running in local development mode.');
     }
-    const eventType = event.payload.event_type;
     let script = null;
     if (baseWorkerPath != null &&
         (options === null || options === void 0 ? void 0 : options.workerPathOverrides) != null &&
-        options.workerPathOverrides[eventType] != null) {
+        options.workerPathOverrides[event.payload.event_type] != null) {
         script =
-            baseWorkerPath + options.workerPathOverrides[eventType];
+            baseWorkerPath +
+                options.workerPathOverrides[event.payload.event_type];
     }
     else {
         script = getWorkerPath({
@@ -109,7 +109,7 @@ async function spawn({ event, initialState, initialDomainMapping, options, baseW
     }
     else {
         const { eventType } = (0, spawn_helpers_1.getNoScriptEventType)(event.payload.event_type);
-        await (0, control_protocol_1.emit)({
+        await (0, emit_1.emit)({
             event,
             eventType,
         });
@@ -188,7 +188,7 @@ class Spawn {
             }
             // If worker sends a message that it has emitted an event, then set alreadyEmitted to true.
             if ((message === null || message === void 0 ? void 0 : message.subject) === workers_1.WorkerMessageSubject.WorkerMessageEmitted) {
-                console.info('Worker has emitted message to the AirSync platform.');
+                console.info('Worker has emitted message to AirSync.');
                 this.alreadyEmitted = true;
             }
             // If worker sends a failure message before exiting, capture it for use in the error event.
@@ -236,7 +236,7 @@ class Spawn {
         this.alreadyEmitted = true;
         const { eventType } = (0, spawn_helpers_1.getTimeoutErrorEventType)(this.event.payload.event_type);
         try {
-            await (0, control_protocol_1.emit)({
+            await (0, emit_1.emit)({
                 eventType,
                 event: this.event,
                 data: {

package/dist/multithreading/worker.js

@@ -1,8 +1,7 @@
 "use strict";
 const { workerData } = require('node:worker_threads');
 require('ts-node').register();
-const { Logger } = require('../logger/logger');
-const { runWithUserLogContext } = require('../logger/logger.context');
+const { Logger, runWithUserLogContext } = require('../logger/logger');
 console = new Logger({ event: workerData.event, options: workerData.options });
 runWithUserLogContext(() => {
     require(workerData.workerPath);

package/dist/repo/repo.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Repo = void 0;
 const constants_1 = require("../common/constants");
 const uploader_1 = require("../uploader/uploader");
-const logger_context_1 = require("../logger/logger.context");
+const logger_1 = require("../logger/logger");
 class Repo {
     constructor({ event, itemType, normalize, onUpload, options, }) {
         this.items = [];
@@ -49,7 +49,7 @@ class Repo {
         if (this.normalize &&
             this.itemType != constants_1.AirSyncDefaultItemTypes.EXTERNAL_DOMAIN_METADATA &&
             this.itemType != constants_1.SSOR_ATTACHMENT) {
-            recordsToPush = (0, logger_context_1.runWithUserLogContext)(() => items.map((item) => this.normalize(item)));
+            recordsToPush = (0, logger_1.runWithUserLogContext)(() => items.map((item) => this.normalize(item)));
         }
         else {
             recordsToPush = items;

package/dist/state/base-state.d.ts

@@ -0,0 +1,75 @@
+import { InitialDomainMapping } from '../types/common';
+import { AirSyncEvent } from '../types/extraction';
+import { ExtractionScope } from '../types/workers';
+import { SdkState, StateInterface } from './state.interfaces';
+/**
+ * BaseState owns the state lifecycle shared by every sync mode: connector vs.
+ * SDK state separation, fetch/init/post against the platform, the v1->v2
+ * migration shim, and the snap-in-version-gated initial domain mapping install.
+ *
+ * Mode-specific subclasses (`ExtractionState`, `LoadingState`) seed the
+ * SDK-owned portion of the state and add mode-specific setup in their factories.
+ *
+ * @typeParam ConnectorState - the connector-owned state shape
+ */
+export declare abstract class BaseState<ConnectorState> {
+    protected _connectorState: ConnectorState;
+    protected _sdkState: SdkState;
+    protected _extractionScope: ExtractionScope;
+    protected readonly initialSdkState: SdkState;
+    protected readonly event: AirSyncEvent;
+    private workerUrl;
+    private devrevToken;
+    private syncUnitId;
+    private requestId;
+    constructor({ event, initialState }: StateInterface<ConnectorState>, initialSdkState: SdkState);
+    /** Connector-owned state. This is what `adapter.state` exposes to snap-in code. */
+    get state(): ConnectorState;
+    set state(value: ConnectorState);
+    /** SDK-internal bookkeeping state. Never exposed to connector code. */
+    get sdkState(): SdkState;
+    set sdkState(value: SdkState);
+    get extractionScope(): ExtractionScope;
+    /**
+     * Installs the initial domain mapping when the snap-in version in state does
+     * not match the version in the event context. Shared by all modes so that a
+     * loading run still installs the mapping if extraction has not done so.
+     * @param initialDomainMapping The initial domain mapping passed to spawn
+     */
+    installInitialDomainMappingIfNeeded(initialDomainMapping?: InitialDomainMapping): Promise<void>;
+    /**
+     * Initializes the state for this adapter instance by fetching from API
+     * or creating an initial state if none exists (404).
+     *
+     * Reads both the v2 `{ connectorState, sdkState }` envelope and a legacy flat
+     * v1 blob (connector keys merged with SDK keys), migrating the latter on read.
+     * Always persists the v2 envelope going forward.
+     * @param initialState The initial connector state provided by the spawn function
+     */
+    init(initialState: ConnectorState): Promise<void>;
+    /**
+     * Normalizes a parsed on-disk state into the `{ connectorState, sdkState }`
+     * envelope, migrating a legacy flat v1 blob if needed.
+     *
+     * - v2 envelope (`{ connectorState, sdkState }`): used as-is.
+     * - v1 flat blob: SDK-owned keys (`V1_SDK_STATE_KEYS`) split into `sdkState`,
+     *   everything else becomes connector state.
+     * - Malformed envelope (one side present, the other missing) fails loud.
+     */
+    private normalizeFetchedState;
+    /**
+     *  Updates the state of the adapter by posting to API.
+     *  Persists the v2 `{ connectorState, sdkState }` envelope.
+     * @param {object} state - The connector state to be updated
+     */
+    postState(state?: ConnectorState): Promise<void>;
+    /**
+     *  Fetches the state of the adapter from API.
+     * @return  The raw state data from API
+     */
+    fetchState(): Promise<{
+        state: string;
+        objects?: string;
+    }>;
+}
+//# sourceMappingURL=base-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-state.d.ts","sourceRoot":"","sources":["../../src/state/base-state.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAEL,QAAQ,EACR,cAAc,EAEf,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;GASG;AACH,8BAAsB,SAAS,CAAC,cAAc;IAC5C,SAAS,CAAC,eAAe,EAAE,cAAc,CAAC;IAC1C,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC9B,SAAS,CAAC,gBAAgB,EAAE,eAAe,CAAM;IACjD,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC;IAC7C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IACvC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;gBAGxB,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,cAAc,CAAC,cAAc,CAAC,EACvD,eAAe,EAAE,QAAQ;IAY3B,mFAAmF;IACnF,IAAI,KAAK,IAAI,cAAc,CAE1B;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,cAAc,EAE9B;IAED,uEAAuE;IACvE,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED,IAAI,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAE3B;IAED,IAAI,eAAe,IAAI,eAAe,CAErC;IAED;;;;;OAKG;IACG,mCAAmC,CACvC,oBAAoB,CAAC,EAAE,oBAAoB,GAC1C,OAAO,CAAC,IAAI,CAAC;IAwChB;;;;;;;;OAQG;IACG,IAAI,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAkDvD;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;IAyC7B;;;;OAIG;IACG,SAAS,CAAC,KAAK,CAAC,EAAE,cAAc;IA4DtC;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAqBjE"}

package/dist/state/base-state.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseState = void 0;
+const axios_1 = __importDefault(require("axios"));
+const node_worker_threads_1 = require("node:worker_threads");
+const install_initial_domain_mapping_1 = require("./install-initial-domain-mapping");
+const client_1 = require("../http/client");
+const logger_1 = require("../logger/logger");
+const workers_1 = require("../types/workers");
+const state_interfaces_1 = require("./state.interfaces");
+/**
+ * BaseState owns the state lifecycle shared by every sync mode: connector vs.
+ * SDK state separation, fetch/init/post against the platform, the v1->v2
+ * migration shim, and the snap-in-version-gated initial domain mapping install.
+ *
+ * Mode-specific subclasses (`ExtractionState`, `LoadingState`) seed the
+ * SDK-owned portion of the state and add mode-specific setup in their factories.
+ *
+ * @typeParam ConnectorState - the connector-owned state shape
+ */
+class BaseState {
+    constructor({ event, initialState }, initialSdkState) {
+        this._extractionScope = {};
+        this.event = event;
+        this.initialSdkState = initialSdkState;
+        this._connectorState = initialState;
+        this._sdkState = Object.assign({}, 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;
+    }
+    /** Connector-owned state. This is what `adapter.state` exposes to snap-in code. */
+    get state() {
+        return this._connectorState;
+    }
+    set state(value) {
+        this._connectorState = value;
+    }
+    /** SDK-internal bookkeeping state. Never exposed to connector code. */
+    get sdkState() {
+        return this._sdkState;
+    }
+    set sdkState(value) {
+        this._sdkState = value;
+    }
+    get extractionScope() {
+        return this._extractionScope;
+    }
+    /**
+     * Installs the initial domain mapping when the snap-in version in state does
+     * not match the version in the event context. Shared by all modes so that a
+     * loading run still installs the mapping if extraction has not done so.
+     * @param initialDomainMapping The initial domain mapping passed to spawn
+     */
+    async installInitialDomainMappingIfNeeded(initialDomainMapping) {
+        const snapInVersionId = this.event.context.snap_in_version_id;
+        const hasSnapInVersionInState = 'snapInVersionId' in this.sdkState;
+        const shouldUpdateIDM = !hasSnapInVersionInState ||
+            this.sdkState.snapInVersionId !== snapInVersionId;
+        if (!shouldUpdateIDM) {
+            console.log(`Snap-in version in state matches the version in event context "${snapInVersionId}". Skipping initial domain mapping installation.`);
+            return;
+        }
+        try {
+            console.log(`Snap-in version in state "${this.sdkState.snapInVersionId}" does not match the version in event context "${snapInVersionId}". Installing initial domain mapping.`);
+            if (initialDomainMapping) {
+                await (0, install_initial_domain_mapping_1.installInitialDomainMapping)(this.event, initialDomainMapping);
+                this.sdkState.snapInVersionId = snapInVersionId;
+            }
+            else {
+                throw new Error('No initial domain mapping was passed to spawn function. Skipping initial domain mapping installation.');
+            }
+        }
+        catch (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);
+        }
+    }
+    /**
+     * Initializes the state for this adapter instance by fetching from API
+     * or creating an initial state if none exists (404).
+     *
+     * Reads both the v2 `{ connectorState, sdkState }` envelope and a legacy flat
+     * v1 blob (connector keys merged with SDK keys), migrating the latter on read.
+     * Always persists the v2 envelope going forward.
+     * @param initialState The initial connector state provided by the spawn function
+     */
+    async init(initialState) {
+        var _a;
+        try {
+            const { state: stringifiedState, objects } = await this.fetchState();
+            if (!stringifiedState) {
+                throw new Error('No state found in response.');
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(stringifiedState);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse state. ${error}`);
+            }
+            const { connectorState, sdkState } = this.normalizeFetchedState(parsed);
+            this.state = connectorState;
+            this.sdkState = sdkState;
+            console.log('State fetched successfully. Current state', {
+                connectorState: (0, logger_1.getPrintableState)(this.state),
+                sdkState: (0, logger_1.getPrintableState)(this.sdkState),
+            });
+            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) {
+                console.log('State not found. Initializing state with initial state.');
+                this.state = initialState;
+                this.sdkState = Object.assign({}, this.initialSdkState);
+                await this.postState();
+            }
+            else {
+                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);
+            }
+        }
+    }
+    /**
+     * Normalizes a parsed on-disk state into the `{ connectorState, sdkState }`
+     * envelope, migrating a legacy flat v1 blob if needed.
+     *
+     * - v2 envelope (`{ connectorState, sdkState }`): used as-is.
+     * - v1 flat blob: SDK-owned keys (`V1_SDK_STATE_KEYS`) split into `sdkState`,
+     *   everything else becomes connector state.
+     * - Malformed envelope (one side present, the other missing) fails loud.
+     */
+    normalizeFetchedState(parsed) {
+        if (parsed === null || typeof parsed !== 'object') {
+            throw new Error('Fetched state is not a JSON object.');
+        }
+        const record = parsed;
+        const hasConnector = 'connectorState' in record;
+        const hasSdk = 'sdkState' in record;
+        if (hasConnector || hasSdk) {
+            if (!hasConnector || !hasSdk) {
+                throw new Error('Malformed state envelope: expected both "connectorState" and "sdkState".');
+            }
+            return {
+                connectorState: record.connectorState,
+                sdkState: Object.assign(Object.assign({}, this.initialSdkState), record.sdkState),
+            };
+        }
+        // Legacy flat v1 blob: split known SDK keys out of the connector state.
+        const connectorState = {};
+        const sdkState = {};
+        for (const [key, value] of Object.entries(record)) {
+            if (state_interfaces_1.V1_SDK_STATE_KEYS.has(key)) {
+                sdkState[key] = value;
+            }
+            else {
+                connectorState[key] = value;
+            }
+        }
+        return {
+            connectorState: connectorState,
+            sdkState: Object.assign(Object.assign({}, this.initialSdkState), sdkState),
+        };
+    }
+    /**
+     *  Updates the state of the adapter by posting to API.
+     *  Persists the v2 `{ connectorState, sdkState }` envelope.
+     * @param {object} state - The connector state to be updated
+     */
+    async postState(state) {
+        const url = this.workerUrl + '.update';
+        this.state = state || this.state;
+        const envelope = {
+            connectorState: this.state,
+            sdkState: this.sdkState,
+        };
+        let stringifiedState;
+        try {
+            stringifiedState = JSON.stringify(envelope);
+        }
+        catch (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 {
+            await client_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', {
+                connectorState: (0, logger_1.getPrintableState)(this.state),
+                sdkState: (0, logger_1.getPrintableState)(this.sdkState),
+            });
+        }
+        catch (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);
+        }
+    }
+    /**
+     *  Fetches the state of the adapter from API.
+     * @return  The raw state data from API
+     */
+    async fetchState() {
+        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 client_1.axiosClient.get(url, {
+            headers: {
+                Authorization: this.devrevToken,
+            },
+            params: {
+                sync_unit: this.syncUnitId,
+                request_id: this.requestId,
+            },
+        });
+        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.BaseState = BaseState;