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

package/dist/mappers/mappers.interfaces.d.ts

@@ -0,0 +1,173 @@
+import { AirSyncEvent } from '../types/extraction';
+import { DonV2 } from '../types/loading';
+export interface MappersFactoryInterface {
+    event: AirSyncEvent;
+}
+export interface UpdateSyncMapperRecordParams {
+    external_ids: {
+        add: string[];
+    };
+    /**
+     * Labels values in `external_ids` with their usage context (e.g. a UUID for
+     * one API call, a login username for another). Not indexed: to look up by a
+     * secondary value it must also be present in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    targets: {
+        add: DonV2[];
+    };
+    status: SyncMapperRecordStatus;
+    /** Input file name(s) containing the object data; helps later debugging. */
+    input_files?: {
+        add: string[];
+    };
+    /**
+     * Prevents update loops: after writing the object to the external system,
+     * add its modified_date here. The Loader skips extracted updates whose
+     * modified_date is listed (the change originated in DevRev).
+     */
+    external_versions?: {
+        add: SyncMapperRecordExternalVersion[];
+    };
+    /** Free-form storage; opaque to the platform. */
+    extra_data?: string;
+}
+/** Links external system entities to DevRev entities. */
+export interface SyncMapperRecord {
+    id: DonV2;
+    external_ids: string[];
+    /**
+     * Labels values in `external_ids` with their usage context (e.g. a UUID for
+     * one API call, a login username for another). Not indexed: to look up by a
+     * secondary value it must also be present in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    targets: DonV2[];
+    status: SyncMapperRecordStatus;
+    /** Input file name(s) containing the object data; helps later debugging. */
+    input_files?: string[];
+    /**
+     * Prevents update loops: after writing the object to the external system,
+     * its modified_date is stored here. The Loader skips extracted updates whose
+     * modified_date is listed (the change originated in DevRev).
+     */
+    external_versions?: SyncMapperRecordExternalVersion[];
+    /** Free-form storage; opaque to the platform. */
+    extra_data?: string;
+}
+export interface MappersGetByTargetIdParams {
+    sync_unit: DonV2;
+    target: DonV2;
+}
+export interface MappersGetByTargetIdResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+export interface MappersCreateParams {
+    sync_unit: DonV2;
+    external_ids: string[];
+    /**
+     * Labels values in `external_ids` with their usage context (e.g. a UUID for
+     * one API call, a login username for another). Not indexed: to look up by a
+     * secondary value it must also be present in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    targets: DonV2[];
+    status: SyncMapperRecordStatus;
+    /** Input file name(s) containing the object data; helps later debugging. */
+    input_files?: string[];
+    /**
+     * Prevents update loops: after writing the object to the external system,
+     * add its modified_date here. The Loader skips extracted updates whose
+     * modified_date is listed (the change originated in DevRev).
+     */
+    external_versions?: SyncMapperRecordExternalVersion[];
+    /** Free-form storage; opaque to the platform. */
+    extra_data?: string;
+}
+export interface MappersCreateResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+export interface MappersUpdateParams {
+    id: DonV2;
+    sync_unit: DonV2;
+    external_ids: {
+        add: string[];
+    };
+    /**
+     * Labels values in `external_ids` with their usage context (e.g. a UUID for
+     * one API call, a login username for another). Not indexed: to look up by a
+     * secondary value it must also be present in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    targets: {
+        add: DonV2[];
+    };
+    status: SyncMapperRecordStatus;
+    /** Input file name(s) containing the object data; helps later debugging. */
+    input_files?: {
+        add: string[];
+    };
+    /**
+     * Prevents update loops: after writing the object to the external system,
+     * add its modified_date here. The Loader skips extracted updates whose
+     * modified_date is listed (the change originated in DevRev).
+     */
+    external_versions?: {
+        add: SyncMapperRecordExternalVersion[];
+    };
+    /** Free-form storage; opaque to the platform. */
+    extra_data?: string;
+}
+export interface MappersUpdateResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+export declare enum SyncMapperRecordStatus {
+    /** The mapping is active and operational (default) */
+    OPERATIONAL = "operational",
+    /** The mapping was filtered out by user filter settings */
+    FILTERED = "filtered",
+    /** Ignore the external object in sync; prevents create/update in DevRev. */
+    IGNORED = "ignored"
+}
+/** Marks external changes as DevRev-originated to prevent update loops. */
+export interface SyncMapperRecordExternalVersion {
+    /** Sync recipe version at the time the external change was written */
+    recipe_version: number;
+    /** External system modified timestamp (ISO 8601 string) used for loop detection */
+    modified_date: string;
+}
+export interface MappersGetByExternalIdParams {
+    sync_unit: DonV2;
+    external_id: string;
+    target_type: SyncMapperRecordTargetType;
+}
+export declare enum SyncMapperRecordTargetType {
+    ACCESS_CONTROL_ENTRY = "access_control_entry",
+    ACCOUNT = "account",
+    AIRDROP_AUTHORIZATION_POLICY = "airdrop_authorization_policy",
+    AIRDROP_FIELD_AUTHORIZATION_POLICY = "airdrop_field_authorization_policy",
+    AIRDROP_PLATFORM_GROUP = "airdrop_platform_group",
+    ARTICLE = "article",
+    ARTIFACT = "artifact",
+    CHAT = "chat",
+    CONVERSATION = "conversation",
+    CUSTOM_OBJECT = "custom_object",
+    DIRECTORY = "directory",
+    GROUP = "group",
+    INCIDENT = "incident",
+    LINK = "link",
+    MEETING = "meeting",
+    OBJECT_MEMBER = "object_member",
+    PART = "part",
+    REV_ORG = "rev_org",
+    ROLE = "role",
+    ROLE_SET = "role_set",
+    TAG = "tag",
+    TIMELINE_COMMENT = "timeline_comment",
+    USER = "user",
+    WORK = "work"
+}
+export interface MappersGetByExternalIdResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+//# sourceMappingURL=mappers.interfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.interfaces.d.ts","sourceRoot":"","sources":["../../src/mappers/mappers.interfaces.ts"],"names":[],"mappings":"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"}

package/dist/mappers/{mappers.interface.js → mappers.interfaces.js}

@@ -1,24 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncMapperRecordTargetType = exports.SyncMapperRecordStatus = void 0;
-/**
- * Status of a sync mapper record indicating its operational state.
- */
 var SyncMapperRecordStatus;
 (function (SyncMapperRecordStatus) {
     /** The mapping is active and operational (default) */
     SyncMapperRecordStatus["OPERATIONAL"] = "operational";
     /** The mapping was filtered out by user filter settings */
     SyncMapperRecordStatus["FILTERED"] = "filtered";
-    /**
-     * The external object should be ignored in sync operations.
-     * Use to prevent objects from being created or updated in DevRev.
-     */
+    /** Ignore the external object in sync; prevents create/update in DevRev. */
     SyncMapperRecordStatus["IGNORED"] = "ignored";
 })(SyncMapperRecordStatus || (exports.SyncMapperRecordStatus = SyncMapperRecordStatus = {}));
-/**
- * Types of DevRev entities that can be targets in sync mapper records.
- */
 var SyncMapperRecordTargetType;
 (function (SyncMapperRecordTargetType) {
     SyncMapperRecordTargetType["ACCESS_CONTROL_ENTRY"] = "access_control_entry";

package/dist/mappers/mappers.js

@@ -1,83 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mappers = void 0;
-const axios_client_internal_1 = require("../http/axios-client-internal");
+const client_1 = require("../http/client");
+const errors_1 = require("../http/errors");
 /**
  * Manages sync mapper records that link external system items to DevRev items.
- *
- * Used for tracking relationships between external and DevRev entities during sync operations.
+ * Lookups resolve to `null` when no record exists; every other failure rejects
+ * with an {@link AirSyncHttpError}.
  */
 class Mappers {
     constructor({ event }) {
         this.devrevApiEndpoint = event.execution_metadata.devrev_endpoint;
         this.devrevApiToken = event.context.secrets.service_account_token;
     }
-    /**
-     * Retrieves a sync mapper record by DevRev ID.
-     *
-     * Used to find the mapping when you know the DevRev ID and want to find the external system ID.
-     *
-     * @param params - Query parameters of type MappersGetByTargetIdParams
-     * @returns Promise with response data containing the sync mapper record
-     */
     async getByTargetId(params) {
         const { sync_unit, target } = params;
-        return axios_client_internal_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
+        return this.lookup(async () => client_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-target`, {
             headers: {
                 Authorization: this.devrevApiToken,
             },
             params: { sync_unit, target },
-        });
+        }));
     }
-    /**
-     * Retrieves a sync mapper record by external system ID.
-     *
-     * Used to find the mapping when you know the external system ID and want to find the DevRev ID.
-     *
-     * @param params - Query parameters of type MappersGetByExternalIdParams
-     * @returns Promise with response data containing the sync mapper record
-     */
     async getByExternalId(params) {
         const { sync_unit, external_id, target_type } = params;
-        return axios_client_internal_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-external-id`, {
+        return this.lookup(async () => client_1.axiosClient.get(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.get-by-external-id`, {
             headers: {
                 Authorization: this.devrevApiToken,
             },
             params: { sync_unit, external_id, target_type },
-        });
+        }));
     }
-    /**
-     * Creates a new sync mapper record to establish a relationship between external system
-     * entities and DevRev entities.
-     *
-     * This is called after importing an item from external system to DevRev to record
-     * the mapping for future synchronization operations.
-     *
-     * @param params - Creation parameters of type MappersCreateParams
-     * @returns Promise with response data containing the created sync mapper record
-     */
+    /** Called after importing an item to DevRev to record the mapping for future syncs. */
     async create(params) {
-        return axios_client_internal_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.create`, params, {
+        return this.call(async () => client_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.create`, params, {
             headers: {
                 Authorization: this.devrevApiToken,
             },
-        });
+        }));
     }
-    /**
-     * Updates an existing sync mapper record.
-     *
-     * Used to modify existing mappings when external system entities change or when
-     * additional DevRev entities need to be associated.
-     *
-     * @param params - Update parameters of type MappersUpdateParams
-     * @returns Promise with response data containing the updated sync mapper record
-     */
     async update(params) {
-        return axios_client_internal_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.update`, params, {
+        return this.call(async () => client_1.axiosClient.post(`${this.devrevApiEndpoint}/internal/airdrop.sync-mapper-record.update`, params, {
             headers: {
                 Authorization: this.devrevApiToken,
             },
-        });
+        }));
+    }
+    async call(request) {
+        try {
+            return (await request()).data;
+        }
+        catch (error) {
+            throw (0, errors_1.toAirSyncHttpError)(error);
+        }
+    }
+    async lookup(request) {
+        try {
+            return (await request()).data;
+        }
+        catch (error) {
+            if ((0, errors_1.isNotFound)(error)) {
+                return null;
+            }
+            throw (0, errors_1.toAirSyncHttpError)(error);
+        }
     }
 }
 exports.Mappers = Mappers;

package/dist/multithreading/adapters/base-adapter.d.ts

@@ -0,0 +1,39 @@
+import { Mappers } from '../../mappers/mappers';
+import { AirSyncEvent } from '../../types/extraction';
+/**
+ * Shared state/behavior for both sync modes; owns the `emit` control-protocol
+ * flow as a template method with mode-specific hooks.
+ */
+export declare abstract class BaseAdapter<ConnectorState> {
+    readonly event: AirSyncEvent;
+    private _hasWorkerEmitted;
+    private _isTimeout;
+    private resolveTimeoutSignal;
+    private _mappers;
+    /** Sync mapper records for this event's sync unit, in both extraction and loading. */
+    get mappers(): Mappers;
+    /** Set once the soft timeout fires; the task should wrap up and return. */
+    get isTimeout(): boolean;
+    /** Connector-owned state exposed to snap-in code. */
+    get state(): ConnectorState;
+    set state(value: ConnectorState);
+    get extractionScope(): import("../../types/workers").ExtractionScope;
+    /**
+     * Persists connector and SDK state right now. State is saved on every emit
+     * anyway; call this only to record intent before an external write that
+     * must not be repeated. Throws if the save fails.
+     */
+    postState(): Promise<void>;
+    /**
+     * Uploads connector-owned data (e.g. state too large to keep inline) as a
+     * gzipped JSONL artifact. Unlike repo uploads it is not reported in the
+     * emitted event. Throws on failure.
+     */
+    uploadArtifact(itemType: string, data: object[]): Promise<{
+        id: string;
+    }>;
+    /** Downloads an artifact written by {@link uploadArtifact}. Throws on failure. */
+    downloadArtifact<T = unknown>(artifactId: string): Promise<T[]>;
+    private send;
+}
+//# sourceMappingURL=base-adapter.d.ts.map

package/dist/multithreading/adapters/base-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-adapter.d.ts","sourceRoot":"","sources":["../../../src/multithreading/adapters/base-adapter.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAKhD,OAAO,EACL,YAAY,EAIb,MAAM,wBAAwB,CAAC;AAYhC;;;GAGG;AACH,8BAAsB,WAAW,CAAC,cAAc;IAC9C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAI7B,OAAO,CAAC,iBAAiB,CAAkB;IAC3C,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,oBAAoB,CAAc;IAU1C,OAAO,CAAC,QAAQ,CAAU;IAsB1B,sFAAsF;IACtF,IAAI,OAAO,IAAI,OAAO,CAErB;IAOD,2EAA2E;IAC3E,IAAI,SAAS,IAAI,OAAO,CAEvB;IAUD,qDAAqD;IACrD,IAAI,KAAK,IAAI,cAAc,CAE1B;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,cAAc,EAE9B;IAOD,IAAI,eAAe,kDAElB;IAED;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC;;;;OAIG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAY1B,kFAAkF;IAC5E,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;YAmIvD,IAAI;CAmCnB"}

package/dist/multithreading/adapters/base-adapter.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAdapter = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const constants_1 = require("../../common/constants");
+const errors_1 = require("../../http/errors");
+const logger_1 = require("../../logger/logger");
+const mappers_1 = require("../../mappers/mappers");
+const errors_2 = require("../../types/errors");
+const workers_1 = require("../../types/workers");
+const uploader_1 = require("../../uploader/uploader");
+const emit_1 = require("../emit");
+const spawn_helpers_1 = require("../spawn/spawn.helpers");
+/**
+ * Shared state/behavior for both sync modes; owns the `emit` control-protocol
+ * flow as a template method with mode-specific hooks.
+ */
+class BaseAdapter {
+    /** @internal */
+    constructor({ event, adapterState, options, }) {
+        this._hasWorkerEmitted = false;
+        this._isTimeout = false;
+        /** @internal */
+        this.timeoutSignal = new Promise((resolve) => {
+            this.resolveTimeoutSignal = resolve;
+        });
+        this.event = event;
+        this.options = options;
+        this.adapterState = adapterState;
+        this.uploader = new uploader_1.Uploader({
+            event,
+            options,
+        });
+        this._mappers = new mappers_1.Mappers({ event });
+    }
+    /** Sync mapper records for this event's sync unit, in both extraction and loading. */
+    get mappers() {
+        return this._mappers;
+    }
+    /** @internal */
+    get hasWorkerEmitted() {
+        return this._hasWorkerEmitted;
+    }
+    /** Set once the soft timeout fires; the task should wrap up and return. */
+    get isTimeout() {
+        return this._isTimeout;
+    }
+    /** @internal */
+    set isTimeout(value) {
+        this._isTimeout = value;
+        if (value) {
+            this.resolveTimeoutSignal();
+        }
+    }
+    /** Connector-owned state exposed to snap-in code. */
+    get state() {
+        return this.adapterState.state;
+    }
+    set state(value) {
+        this.adapterState.state = value;
+    }
+    /** @internal */
+    get sdkState() {
+        return this.adapterState.sdkState;
+    }
+    get extractionScope() {
+        return this.adapterState.extractionScope;
+    }
+    /**
+     * Persists connector and SDK state right now. State is saved on every emit
+     * anyway; call this only to record intent before an external write that
+     * must not be repeated. Throws if the save fails.
+     */
+    async postState() {
+        await this.adapterState.postState();
+    }
+    /**
+     * Uploads connector-owned data (e.g. state too large to keep inline) as a
+     * gzipped JSONL artifact. Unlike repo uploads it is not reported in the
+     * emitted event. Throws on failure.
+     */
+    async uploadArtifact(itemType, data) {
+        var _a;
+        const { artifact, error } = await this.uploader.upload(itemType, data);
+        if (error || !artifact) {
+            throw new errors_1.AirSyncHttpError(`Failed to upload artifact of type ${itemType}. ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : 'No artifact returned.'}`);
+        }
+        return { id: artifact.id };
+    }
+    /** Downloads an artifact written by {@link uploadArtifact}. Throws on failure. */
+    async downloadArtifact(artifactId) {
+        const { response, error } = await this.uploader.getJsonObjectByArtifactId({
+            artifactId,
+            isGzipped: true,
+        });
+        if (error !== undefined || response === undefined) {
+            throw error instanceof errors_1.AirSyncHttpError
+                ? error
+                : new errors_1.AirSyncHttpError(`Failed to download artifact ${artifactId}. ${(0, logger_1.serializeError)(error)}`);
+        }
+        return (Array.isArray(response) ? response : [response]);
+    }
+    /**
+     * @internal
+     * Mode-specific worker metadata merged into the emitted event. The library
+     * version and state-date range are added centrally in `emit`, so subclasses
+     * only contribute their own statistics.
+     */
+    buildWorkerMetadata(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    newEventType) {
+        return undefined;
+    }
+    /** @internal Runs before a failure is reported via `emitError`. */
+    beforeErrorEmit() { }
+    /**
+     * Maps a {@link TaskResult} to the phase-appropriate platform event and emits
+     * it exactly once. Invoked by the worker driver, not by connectors —
+     * connectors signal outcomes by returning a `TaskResult`, never by emitting.
+     *
+     * @internal
+     */
+    async emitFromResult(result) {
+        const { eventType, illegal } = (0, spawn_helpers_1.getEventTypeForResult)(this.event.payload.event_type, result.status);
+        const data = {};
+        if (result.status === 'delay') {
+            data.delay = result.delaySeconds;
+        }
+        else if (result.status === 'error') {
+            data.error = result.error;
+        }
+        else if (illegal) {
+            data.error = {
+                message: `Worker returned status '${result.status}' for a non-resumable phase (${this.event.payload.event_type}), which is not allowed. Emitting an error event instead.`,
+            };
+        }
+        await this.emit(eventType, data);
+    }
+    /** @internal */
+    async emit(newEventType, data) {
+        if (this._hasWorkerEmitted) {
+            console.warn(`Trying to emit event with event type: ${newEventType}. Ignoring emit request because it has already been emitted.`);
+            return;
+        }
+        try {
+            await this.beforeEmit(newEventType);
+            // Save state on every emit, except for start and delete events
+            if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
+                console.log(`Saving state before emitting event with event type: ${newEventType}.`);
+                await this.adapterState.postState();
+            }
+        }
+        catch (error) {
+            console.error('Error while preparing event for emission.', (0, logger_1.serializeError)(error));
+            await this.emitError(error);
+            return;
+        }
+        await this.send(newEventType, data);
+    }
+    /**
+     * Emits the phase error for a failed task or pre-emit step. Skips the
+     * pre-emit flush and state save, so a failed batch isn't retried; artifacts
+     * uploaded before the failure are still reported.
+     *
+     * @internal
+     */
+    async emitError(error) {
+        if (this._hasWorkerEmitted) {
+            return;
+        }
+        this.beforeErrorEmit();
+        const { eventType } = (0, spawn_helpers_1.getEventTypeForResult)(this.event.payload.event_type, 'error');
+        await this.send(eventType, { error: { message: (0, logger_1.serializeError)(error) } });
+    }
+    async send(newEventType, data) {
+        try {
+            if (data === null || data === void 0 ? void 0 : data.error) {
+                data.error = toWireError(data.error);
+            }
+            await (0, emit_1.emit)({
+                eventType: newEventType,
+                event: this.event,
+                data: Object.assign(Object.assign({}, data), this.buildEmitPayload(newEventType)),
+                worker_metadata: this.buildWorkerMetadata(newEventType),
+            });
+            const message = {
+                subject: workers_1.WorkerMessageSubject.WorkerMessageEmitted,
+                payload: { eventType: newEventType },
+            };
+            this.afterEmit(newEventType);
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(message);
+            this._hasWorkerEmitted = true;
+        }
+        catch (error) {
+            console.error(`Error while emitting event with event type: ${newEventType}.`, (0, logger_1.serializeError)(error));
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage(workers_1.WorkerMessageSubject.WorkerMessageExit);
+            this._hasWorkerEmitted = true;
+        }
+    }
+}
+exports.BaseAdapter = BaseAdapter;
+/**
+ * The platform matches error codes against the whole message, so a coded
+ * error is sent as just the code and its details only go to the logs.
+ */
+function toWireError({ message, code }) {
+    if (!code) {
+        return { message: (0, logger_1.truncateMessage)(message) };
+    }
+    console.error(`Reporting ${code}: ${message}`);
+    return { message: (0, errors_2.formatErrorCode)(code) };
+}

package/dist/multithreading/adapters/extraction-adapter.d.ts

@@ -0,0 +1,49 @@
+import { Repo } from '../../repo/repo';
+import { NormalizedAttachment, RepoInterface } from '../../repo/repo.interfaces';
+import { ExternalSystemAttachmentProcessors, ExternalSystemAttachmentStreamingFunction, ItemTypeCount, ProcessAttachmentReturnType } from '../../types/extraction';
+import { TaskResult } from '../../types/workers';
+import { Artifact } from '../../uploader/uploader.interfaces';
+import { BaseAdapter } from './base-adapter';
+/** Adapter passed to extraction tasks (repos, artifacts, attachment streaming). @public */
+export declare class ExtractionAdapter<ConnectorState> extends BaseAdapter<ConnectorState> {
+    private _artifacts;
+    private _preExtractionItemCounts?;
+    private repos;
+    private lastExtractedItemType?;
+    private currentEventDataLength;
+    /** Defaults to true if the scope is empty or the item type is not listed. */
+    shouldExtract(itemType: string): boolean;
+    initializeRepos(repos: RepoInterface[]): void;
+    private createRepo;
+    /**
+     * SSOR attachments created outside the attachments phase are held in state
+     * and reported with ATTACHMENT_EXTRACTION_DONE instead of the current event.
+     */
+    private isDeferredRepo;
+    private isAttachmentsPhase;
+    private getOrCreateSsorRepo;
+    getRepo(itemType: string): Repo | undefined;
+    /** Artifacts uploaded so far that the next emit will report. */
+    get artifacts(): readonly Artifact[];
+    private addArtifacts;
+    /**
+     * Per-record-type counts for sync-duration estimation. Set during the
+     * metadata phase; the SDK attaches them to the metadata-done event.
+     */
+    get preExtractionItemCounts(): ItemTypeCount[] | undefined;
+    set preExtractionItemCounts(counts: ItemTypeCount[] | undefined);
+    private toRfc3339Timestamp;
+    private uploadAllRepos;
+    /**
+     * Streams one attachment into DevRev. Usable in any extraction phase; SSOR
+     * records created outside the attachments phase are reported with
+     * ATTACHMENT_EXTRACTION_DONE.
+     */
+    processAttachment(attachment: NormalizedAttachment, stream: ExternalSystemAttachmentStreamingFunction): Promise<ProcessAttachmentReturnType>;
+    streamAttachments<NewBatch>({ stream, processors, batchSize, }: {
+        stream: ExternalSystemAttachmentStreamingFunction;
+        processors?: ExternalSystemAttachmentProcessors<ConnectorState, NormalizedAttachment[], NewBatch>;
+        batchSize?: number;
+    }): Promise<TaskResult>;
+}
+//# sourceMappingURL=extraction-adapter.d.ts.map

package/dist/multithreading/adapters/extraction-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-adapter.d.ts","sourceRoot":"","sources":["../../../src/multithreading/adapters/extraction-adapter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EACL,oBAAoB,EACpB,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAIL,kCAAkC,EAClC,yCAAyC,EAEzC,aAAa,EACb,2BAA2B,EAE5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAkB,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,QAAQ,EAAkB,MAAM,oCAAoC,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,2FAA2F;AAC3F,qBAAa,iBAAiB,CAC5B,cAAc,CACd,SAAQ,WAAW,CAAC,cAAc,CAAC;IACnC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,wBAAwB,CAAC,CAAkB;IACnD,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,sBAAsB,CAAa;IAY3C,6EAA6E;IAC7E,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAOxC,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE;IAatC,OAAO,CAAC,UAAU;IAoDlB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAW3C,gEAAgE;IAChE,IAAI,SAAS,IAAI,SAAS,QAAQ,EAAE,CAEnC;IAED,OAAO,CAAC,YAAY;IAMpB;;;OAGG;IACH,IAAI,uBAAuB,IAAI,aAAa,EAAE,GAAG,SAAS,CAEzD;IAED,IAAI,uBAAuB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,SAAS,EAE9D;IA6HD,OAAO,CAAC,kBAAkB;YAaZ,cAAc;IAmB5B;;;;OAIG;IACG,iBAAiB,CACrB,UAAU,EAAE,oBAAoB,EAChC,MAAM,EAAE,yCAAyC,GAChD,OAAO,CAAC,2BAA2B,CAAC;IAwGjC,iBAAiB,CAAC,QAAQ,EAAE,EAChC,MAAM,EACN,UAAU,EACV,SAAa,GACd,EAAE;QACD,MAAM,EAAE,yCAAyC,CAAC;QAClD,UAAU,CAAC,EAAE,kCAAkC,CAC7C,cAAc,EACd,oBAAoB,EAAE,EACtB,QAAQ,CACT,CAAC;QACF,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GAAG,OAAO,CAAC,UAAU,CAAC;CAsHxB"}