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

package/dist/testing/mock-server.interfaces.d.ts

@@ -0,0 +1,54 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const DEFAULT_MOCK_SERVER_PORT = 3001;
+export interface ParsedRequest extends IncomingMessage {
+    /** URL path without query string */
+    path: string;
+    /** Parsed JSON body (if any) */
+    body?: unknown;
+}
+export interface MockResponse extends ServerResponse {
+    set(headers: Record<string, string>): MockResponse;
+    status(code: number): MockResponse;
+    json(data: unknown): void;
+    buffer(data: Buffer): void;
+    send(): void;
+}
+/** Simulates failures before succeeding. */
+export interface RetryConfig {
+    /** Failures before success (default: 4) */
+    failureCount?: number;
+    /** Status code during failures (default: 500) */
+    errorStatus?: number;
+    errorBody?: unknown;
+    headers?: Record<string, string>;
+    /** Delay in ms before each failure response */
+    delay?: number;
+}
+export interface RouteConfig {
+    path: string;
+    method: string;
+    status: number;
+    body?: unknown;
+    /** Raw binary body, e.g. gzipped JSONL (takes precedence over `body`) */
+    bodyBuffer?: Buffer;
+    headers?: Record<string, string>;
+    retry?: RetryConfig;
+    /** Succeed for the first `successCount` requests, then fail (partial-upload scenarios). */
+    succeedThenFail?: {
+        successCount: number;
+        errorStatus?: number;
+        errorBody?: unknown;
+    };
+    /** Delay in ms before sending the response */
+    delay?: number;
+}
+export type RouteHandler = (req: ParsedRequest, res: MockResponse) => unknown;
+export interface RequestInfo {
+    method: string;
+    url: string;
+    body?: unknown;
+}
+export type RouteHandlers = Map<string, RouteHandler>;
+/** Request counts per route. */
+export type RequestCounts = Map<string, number>;
+//# sourceMappingURL=mock-server.interfaces.d.ts.map

package/dist/testing/mock-server.interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.interfaces.d.ts","sourceRoot":"","sources":["../../src/testing/mock-server.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEvD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC;IACnD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC;IACnC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,IAAI,IAAI,CAAC;CACd;AAED,4CAA4C;AAC5C,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,2FAA2F;IAC3F,eAAe,CAAC,EAAE;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,CAAC;IACF,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC;AAE9E,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEtD,gCAAgC;AAChC,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}

package/dist/testing/mock-server.interfaces.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MOCK_SERVER_PORT = void 0;
+exports.DEFAULT_MOCK_SERVER_PORT = 3001;

package/dist/testing/mock-server.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockServer = exports.MOCK_SERVER_DEFAULT_URL = void 0;
+const http_1 = require("http");
+const mock_server_interfaces_1 = require("./mock-server.interfaces");
+// Port 0 lets the OS assign a free port at listen time; tests read the
+// resolved URL from `mockServer.baseUrl`.
+exports.MOCK_SERVER_DEFAULT_URL = 'http://localhost:0';
+const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10mb
+async function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                reject(new Error('Request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            if (chunks.length === 0) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                const raw = Buffer.concat(chunks).toString('utf-8');
+                resolve(JSON.parse(raw));
+            }
+            catch (_a) {
+                resolve(undefined);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function wrapResponse(res) {
+    const mock = res;
+    let statusCode = 200;
+    mock.set = (headers) => {
+        for (const [key, value] of Object.entries(headers)) {
+            res.setHeader(key, value);
+        }
+        return mock;
+    };
+    mock.status = (code) => {
+        statusCode = code;
+        return mock;
+    };
+    mock.json = (data) => {
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    mock.buffer = (data) => {
+        res.writeHead(statusCode, { 'Content-Type': 'application/octet-stream' });
+        res.end(data);
+    };
+    mock.send = () => {
+        res.writeHead(statusCode);
+        res.end();
+    };
+    return mock;
+}
+/**
+ * Mocks internal AirSync endpoints in tests, with per-test route
+ * configuration to simulate different response scenarios.
+ */
+class MockServer {
+    constructor(port = mock_server_interfaces_1.DEFAULT_MOCK_SERVER_PORT) {
+        this.server = null;
+        this.routeHandlers = new Map();
+        this.requests = [];
+        this.requestCounts = new Map();
+        this.internalPort = port;
+        this.port = port;
+        this.baseUrl = `http://localhost:${this.port}`;
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = (0, http_1.createServer)((req, res) => {
+                this.handleRequest(req, res).catch(() => {
+                    res.writeHead(500);
+                    res.end();
+                });
+            });
+            this.server.listen(this.internalPort, () => {
+                var _a, _b;
+                const actualPort = (_b = (_a = this.server) === null || _a === void 0 ? void 0 : _a.address()) === null || _b === void 0 ? void 0 : _b.port;
+                if (actualPort) {
+                    this.port = actualPort;
+                    this.baseUrl = `http://localhost:${this.port}`;
+                }
+                console.log(`Mock server running on http://localhost:${this.port}.`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.server) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    console.log('Mock server stopped.');
+                    this.server = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    async handleRequest(raw, rawRes) {
+        const req = raw;
+        const res = wrapResponse(rawRes);
+        const urlPath = (req.url || '/').split('?')[0];
+        req.path = urlPath;
+        req.body = await parseJsonBody(req);
+        const requestInfo = Object.assign({ method: req.method || 'GET', url: req.url || urlPath }, (req.body !== undefined && req.body !== null
+            ? { body: req.body }
+            : {}));
+        this.requests.push(requestInfo);
+        const method = (req.method || 'GET').toUpperCase();
+        const key = `${method}:${urlPath}`;
+        const customHandler = this.routeHandlers.get(key);
+        if (customHandler) {
+            customHandler(req, res);
+        }
+        else {
+            this.defaultRouteHandler(req, res);
+        }
+    }
+    /** Falls back to { success: true } for routes not explicitly set. */
+    defaultRouteHandler(req, res) {
+        if (req.method === 'GET' && req.path === '/worker_data_url.get') {
+            res.status(200).json({
+                state: JSON.stringify({}),
+            });
+        }
+        else if (req.method === 'GET' && req.path === '/internal/snap-ins.get') {
+            res.status(200).json({
+                snap_in: {
+                    imports: [{ name: 'test_import_slug' }],
+                    snap_in_version: { slug: 'test_snap_in_slug' },
+                },
+            });
+        }
+        else if (req.method === 'GET' &&
+            req.path === '/internal/airdrop.artifacts.upload-url') {
+            const artifactId = `artifact-${Date.now()}-${Math.random()
+                .toString(36)
+                .substr(2, 9)}`;
+            res.status(200).json({
+                upload_url: `${this.baseUrl}/file-upload-url`,
+                artifact_id: artifactId,
+                form_data: [],
+            });
+        }
+        else {
+            res.status(200).json({ success: true });
+        }
+    }
+    getRouteKey(method, path) {
+        return `${method.toUpperCase()}:${path}`;
+    }
+    setRoute(config) {
+        const { path, method, status, body, bodyBuffer, retry, succeedThenFail, headers, delay, } = config;
+        const key = this.getRouteKey(method, path);
+        if (retry || succeedThenFail) {
+            this.requestCounts.set(key, 0);
+        }
+        this.routeHandlers.set(key, (req, res) => {
+            const sendResponse = (responseDelay) => {
+                const send = () => {
+                    var _a, _b, _c;
+                    if (succeedThenFail) {
+                        const currentCount = this.requestCounts.get(key) || 0;
+                        this.requestCounts.set(key, currentCount + 1);
+                        if (currentCount < succeedThenFail.successCount) {
+                            if (headers) {
+                                res.set(headers);
+                            }
+                            if (bodyBuffer !== undefined) {
+                                res.status(status).buffer(bodyBuffer);
+                            }
+                            else if (body !== undefined) {
+                                res.status(status).json(body);
+                            }
+                            else {
+                                this.defaultRouteHandler(req, res);
+                            }
+                        }
+                        else {
+                            const errorStatus = (_a = succeedThenFail.errorStatus) !== null && _a !== void 0 ? _a : 400;
+                            if (succeedThenFail.errorBody !== undefined) {
+                                res.status(errorStatus).json(succeedThenFail.errorBody);
+                            }
+                            else {
+                                res.status(errorStatus).send();
+                            }
+                        }
+                    }
+                    else if (retry) {
+                        const currentCount = this.requestCounts.get(key) || 0;
+                        const failureCount = (_b = retry.failureCount) !== null && _b !== void 0 ? _b : 4;
+                        const errorStatus = (_c = retry.errorStatus) !== null && _c !== void 0 ? _c : 500;
+                        if (currentCount < failureCount) {
+                            this.requestCounts.set(key, currentCount + 1);
+                            const sendFailure = () => {
+                                if (retry.headers) {
+                                    res.set(retry.headers);
+                                }
+                                if (retry.errorBody !== undefined) {
+                                    res.status(errorStatus).json(retry.errorBody);
+                                }
+                                else {
+                                    res.status(errorStatus).send();
+                                }
+                            };
+                            if (retry.delay) {
+                                setTimeout(sendFailure, retry.delay);
+                            }
+                            else {
+                                sendFailure();
+                            }
+                        }
+                        else {
+                            this.requestCounts.set(key, currentCount + 1);
+                            if (headers) {
+                                res.set(headers);
+                            }
+                            if (bodyBuffer !== undefined) {
+                                res.status(status).buffer(bodyBuffer);
+                            }
+                            else if (body !== undefined) {
+                                res.status(status).json(body);
+                            }
+                            else {
+                                this.defaultRouteHandler(req, res);
+                            }
+                        }
+                    }
+                    else {
+                        if (headers) {
+                            res.set(headers);
+                        }
+                        if (bodyBuffer !== undefined) {
+                            res.status(status).buffer(bodyBuffer);
+                        }
+                        else if (body !== undefined) {
+                            res.status(status).json(body);
+                        }
+                        else {
+                            res.status(status).send();
+                        }
+                    }
+                };
+                if (responseDelay) {
+                    setTimeout(send, responseDelay);
+                }
+                else {
+                    send();
+                }
+            };
+            sendResponse(delay);
+        });
+    }
+    /** Restores default handlers and clears request tracking data. */
+    resetRoutes() {
+        this.routeHandlers.clear();
+        this.requestCounts.clear();
+        this.requests = [];
+    }
+    getLastRequest() {
+        if (this.requests.length === 0) {
+            return undefined;
+        }
+        return this.requests[this.requests.length - 1];
+    }
+    /** POST requests to the platform callback URL, i.e. emitted events. */
+    getCallbackRequests() {
+        return this.requests.filter((req) => req.method.toUpperCase() === 'POST' && req.url.includes('callback_url'));
+    }
+    getRequestCount(method, path) {
+        return this.getRequests(method, path).length;
+    }
+    getRequests(method, path) {
+        const pathWithoutQuery = path.split('?')[0];
+        return this.requests.filter((req) => req.method.toUpperCase() === method.toUpperCase() &&
+            req.url.split('?')[0] === pathWithoutQuery);
+    }
+}
+exports.MockServer = MockServer;

package/dist/testing/test-adapters.d.ts

@@ -0,0 +1,22 @@
+import { ExtractionAdapter } from '../multithreading/adapters/extraction-adapter';
+import { LoadingAdapter } from '../multithreading/adapters/loading-adapter';
+import { AirSyncEvent } from '../types/extraction';
+import { FileToLoad } from '../types/loading';
+import { SpawnOptions } from '../types/workers';
+export interface TestAdapterParams<ConnectorState> {
+    event: AirSyncEvent;
+    initialState: ConnectorState;
+    options?: SpawnOptions;
+}
+export interface TestLoadingAdapterParams<ConnectorState> extends TestAdapterParams<ConnectorState> {
+    /** Transformer files to resume from, as if a START_* event had set them. */
+    filesToLoad?: FileToLoad[];
+}
+/**
+ * Builds an extraction adapter for connector tests without fetching state.
+ * Platform calls still go to the event's URLs; point them at a MockServer.
+ */
+export declare function createTestExtractionAdapter<ConnectorState>({ event, initialState, options, }: TestAdapterParams<ConnectorState>): ExtractionAdapter<ConnectorState>;
+/** Loading counterpart of {@link createTestExtractionAdapter}. */
+export declare function createTestLoadingAdapter<ConnectorState>({ event, initialState, filesToLoad, options, }: TestLoadingAdapterParams<ConnectorState>): LoadingAdapter<ConnectorState>;
+//# sourceMappingURL=test-adapters.d.ts.map

package/dist/testing/test-adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-adapters.d.ts","sourceRoot":"","sources":["../../src/testing/test-adapters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAG5E,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,MAAM,WAAW,iBAAiB,CAAC,cAAc;IAC/C,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,cAAc,CAAC;IAC7B,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB,CAAC,cAAc,CACtD,SAAQ,iBAAiB,CAAC,cAAc,CAAC;IACzC,4EAA4E;IAC5E,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,cAAc,EAAE,EAC1D,KAAK,EACL,YAAY,EACZ,OAAO,GACR,EAAE,iBAAiB,CAAC,cAAc,CAAC,GAAG,iBAAiB,CAAC,cAAc,CAAC,CAOvE;AAED,kEAAkE;AAClE,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,EACvD,KAAK,EACL,YAAY,EACZ,WAAW,EACX,OAAO,GACR,EAAE,wBAAwB,CAAC,cAAc,CAAC,GAAG,cAAc,CAAC,cAAc,CAAC,CAU3E"}

package/dist/testing/test-adapters.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestExtractionAdapter = createTestExtractionAdapter;
+exports.createTestLoadingAdapter = createTestLoadingAdapter;
+const extraction_adapter_1 = require("../multithreading/adapters/extraction-adapter");
+const loading_adapter_1 = require("../multithreading/adapters/loading-adapter");
+const extraction_state_1 = require("../state/extraction-state");
+const loading_state_1 = require("../state/loading-state");
+/**
+ * Builds an extraction adapter for connector tests without fetching state.
+ * Platform calls still go to the event's URLs; point them at a MockServer.
+ */
+function createTestExtractionAdapter({ event, initialState, options, }) {
+    const adapterState = new extraction_state_1.ExtractionState({
+        event,
+        initialState,
+        options,
+    });
+    return new extraction_adapter_1.ExtractionAdapter({ event, adapterState, options });
+}
+/** Loading counterpart of {@link createTestExtractionAdapter}. */
+function createTestLoadingAdapter({ event, initialState, filesToLoad, options, }) {
+    const adapterState = new loading_state_1.LoadingState({
+        event,
+        initialState,
+        options,
+    });
+    if (filesToLoad) {
+        adapterState.sdkState.fromDevRev = { filesToLoad };
+    }
+    return new loading_adapter_1.LoadingAdapter({ event, adapterState, options });
+}

package/dist/types/common.d.ts

@@ -1,47 +1,14 @@
-import { Artifact } from '../uploader/uploader.interfaces';
-/**
- * ErrorLevel is an enum that represents the level of an error.
- * @deprecated
- */
-export declare enum ErrorLevel {
-    Warning = "WARNING",
-    Error = "ERROR",
-    Info = "INFO"
-}
-/**
- * ErrorRecord is an interface that defines the structure of an error record.
- */
+import { AirSyncErrorCode } from './errors';
 export interface ErrorRecord {
     message: string;
+    /** Platform-recognized condition; when set, it replaces the wire message. */
+    code?: AirSyncErrorCode;
 }
-/**
- * LogRecord is an interface that defines the structure of a log record.
- * @deprecated
- */
-export interface LogRecord {
-    level: ErrorLevel;
-    message: string;
-}
-/**
- * AdapterUpdateParams is an interface that defines the structure of the parameters that can be passed to the update adapter.
- * @deprecated
- */
-export interface AdapterUpdateParams {
-    artifact?: Artifact;
-}
-/**
- * InitialDomainMapping is an interface that defines the structure of the initial domain mapping.
- */
 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.
- */
+/** INITIAL = first import, INCREMENTAL = subsequent syncs, LOADING = DevRev to external system. */
 export declare enum SyncMode {
     INITIAL = "INITIAL",
     INCREMENTAL = "INCREMENTAL",

package/dist/types/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAE3D;;;GAGG;AACH,oBAAY,UAAU;IACpB,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,mGAAmG;AACnG,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB"}

package/dist/types/common.js

@@ -1,22 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncMode = exports.ErrorLevel = void 0;
-/**
- * ErrorLevel is an enum that represents the level of an error.
- * @deprecated
- */
-var ErrorLevel;
-(function (ErrorLevel) {
-    ErrorLevel["Warning"] = "WARNING";
-    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.
- */
+exports.SyncMode = void 0;
+/** INITIAL = first import, INCREMENTAL = subsequent syncs, LOADING = DevRev to external system. */
 var SyncMode;
 (function (SyncMode) {
     SyncMode["INITIAL"] = "INITIAL";

package/dist/types/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Error codes the platform reacts to (e.g. stopping periodic syncs). Set them
+ * on `ErrorRecord.code`; the platform matches the code exactly, so the SDK
+ * sends it as the whole wire message.
+ */
+export declare enum AirSyncErrorCode {
+    EXTERNAL_SYNC_UNIT_DELETED = "EXTERNAL_SYNC_UNIT_DELETED",
+    EXTERNAL_SYNC_UNIT_DEACTIVATED = "EXTERNAL_SYNC_UNIT_DEACTIVATED",
+    USER_DELETED = "USER_DELETED",
+    EXTERNAL_SYSTEM_NO_ACCESS = "EXTERNAL_SYSTEM_NO_ACCESS",
+    EXTERNAL_SYSTEM_NO_PERMISSION = "EXTERNAL_SYSTEM_NO_PERMISSION",
+    HISTORICAL_DATA_EXTRACTION_DONE = "HISTORICAL_DATA_EXTRACTION_DONE"
+}
+export declare function formatErrorCode(code: AirSyncErrorCode): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,oBAAY,gBAAgB;IAG1B,0BAA0B,+BAA+B;IACzD,8BAA8B,mCAAmC;IACjE,YAAY,iBAAiB;IAG7B,yBAAyB,8BAA8B;IAEvD,6BAA6B,kCAAkC;IAE/D,+BAA+B,oCAAoC;CACpE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAE9D"}

package/dist/types/errors.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AirSyncErrorCode = void 0;
+exports.formatErrorCode = formatErrorCode;
+const ERROR_PREFIX = 'ERROR_CODE';
+const ERROR_DELIMITER = '=';
+/**
+ * Error codes the platform reacts to (e.g. stopping periodic syncs). Set them
+ * on `ErrorRecord.code`; the platform matches the code exactly, so the SDK
+ * sends it as the whole wire message.
+ */
+var AirSyncErrorCode;
+(function (AirSyncErrorCode) {
+    // Persistent conditions (system deleted, deactivated, access permanently
+    // revoked) that require stopping periodic syncs, not transient failures.
+    AirSyncErrorCode["EXTERNAL_SYNC_UNIT_DELETED"] = "EXTERNAL_SYNC_UNIT_DELETED";
+    AirSyncErrorCode["EXTERNAL_SYNC_UNIT_DEACTIVATED"] = "EXTERNAL_SYNC_UNIT_DEACTIVATED";
+    AirSyncErrorCode["USER_DELETED"] = "USER_DELETED";
+    // Could not find an accessible resource in the source system.
+    AirSyncErrorCode["EXTERNAL_SYSTEM_NO_ACCESS"] = "EXTERNAL_SYSTEM_NO_ACCESS";
+    // The user is missing a required permission.
+    AirSyncErrorCode["EXTERNAL_SYSTEM_NO_PERMISSION"] = "EXTERNAL_SYSTEM_NO_PERMISSION";
+    // The historical periodic sync reached the end; nothing left to extract.
+    AirSyncErrorCode["HISTORICAL_DATA_EXTRACTION_DONE"] = "HISTORICAL_DATA_EXTRACTION_DONE";
+})(AirSyncErrorCode || (exports.AirSyncErrorCode = AirSyncErrorCode = {}));
+function formatErrorCode(code) {
+    return `${ERROR_PREFIX}${ERROR_DELIMITER}${code}`;
+}