@devrev/airsync-sdk 2.0.0-beta.0

package/dist/deprecated/adapter/index.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapter = void 0;
+exports.createAdapter = createAdapter;
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../../common/constants");
+const helpers_1 = require("../common/helpers");
+// import { Logger } from '../../logger/logger';
+const state_1 = require("../../state/state");
+const event_type_translation_1 = require("../../common/event-type-translation");
+const logger_context_1 = require("../../logger/logger.context");
+/**
+ * Adapter class is used to interact with Airdrop platform. The class provides
+ * utilities to
+ *  - emit control events to the platform
+ *  - update the state of the extractor
+ *  - set the last saved state in case of a timeout
+ *
+ * @class Adapter
+ * @constructor
+ * @deprecated
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param {object=} initialState - The initial state of the adapter
+ * @param {boolean=} isLocalDevelopment - A flag to indicate if the adapter is being used in local development
+ */
+/**
+ *  Creates an adapter instance.
+ *
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param initialState
+ * @param {boolean=} isLocalDevelopment - A flag to indicate if the adapter is being used in local development
+ * @return  The adapter instance
+ */
+async function createAdapter(event, initialState, isLocalDevelopment = false) {
+    event.payload.event_type = (0, event_type_translation_1.translateIncomingEventType)(event.payload.event_type);
+    const newInitialState = structuredClone(initialState);
+    const adapterState = await (0, state_1.createAdapterState)({
+        event,
+        initialState: newInitialState,
+    });
+    const a = new Adapter(event, adapterState, isLocalDevelopment);
+    return a;
+}
+class Adapter {
+    constructor(event, adapterState, isLocalDevelopment = false) {
+        this.exit = false;
+        this.lambdaTimeout = 10 * 60 * 1000; // 10 minutes in milliseconds
+        this.heartBeatInterval = 30 * 1000; // 30 seconds in milliseconds
+        if (!isLocalDevelopment) {
+            //   Logger.init(event);
+        }
+        this.adapterState = adapterState;
+        this._artifacts = [];
+        this.event = event;
+        this.callbackUrl = event.payload.event_context.callback_url;
+        this.devrevToken = event.context.secrets.service_account_token;
+        this.startTime = Date.now();
+        // Run heartbeat every 30 seconds
+        this.heartBeatFn = setInterval(async () => {
+            const b = await this.heartbeat();
+            if (b) {
+                this.exitAdapter();
+            }
+        }, this.heartBeatInterval);
+    }
+    get state() {
+        return this.adapterState.state;
+    }
+    set state(value) {
+        this.adapterState.state = value;
+    }
+    get artifacts() {
+        return this._artifacts;
+    }
+    set artifacts(value) {
+        this._artifacts = value;
+    }
+    /**
+     *  Emits an event to the platform.
+     *
+     * @param {ExtractorEventType} newEventType - The event type to be emitted
+     * @param {EventData=} data - The data to be sent with the event
+     */
+    async emit(newEventType, data) {
+        if (this.exit) {
+            console.warn('Adapter is already in exit state. No more events can be emitted.');
+            return;
+        }
+        // We want to save the state every time we emit an event, except for the start and delete events
+        if (!constants_1.STATELESS_EVENT_TYPES.includes(this.event.payload.event_type)) {
+            (0, logger_context_1.runWithSdkLogContext)(() => console.log(`Saving state before emitting event`));
+            await this.adapterState.postState(this.state);
+        }
+        const newEvent = {
+            event_type: newEventType,
+            event_context: this.event.payload.event_context,
+            event_data: Object.assign({}, data),
+        };
+        try {
+            await axios_1.default.post(this.callbackUrl, Object.assign({}, newEvent), {
+                headers: {
+                    Accept: 'application/json, text/plain, */*',
+                    Authorization: this.devrevToken,
+                    'Content-Type': 'application/json',
+                },
+            });
+            console.log('Successfully emitted event: ' + JSON.stringify(newEvent));
+        }
+        catch (error) {
+            // If this request fails the extraction will be stuck in loop and
+            // we need to stop it through UI or think about retrying this request
+            console.log('Failed to emit event: ' +
+                JSON.stringify(newEvent) +
+                ', error: ' +
+                error);
+        }
+        finally {
+            this.exitAdapter();
+        }
+    }
+    /**
+     * Exit the adapter. This will stop the heartbeat and no
+     * further events will be emitted.
+     */
+    exitAdapter() {
+        this.exit = true;
+    }
+    /**
+     * Heartbeat function to check if the lambda is about to timeout.
+     * @returns true if 10 minutes have passed since the start of the lambda.
+     */
+    async heartbeat() {
+        if (this.exit) {
+            return true;
+        }
+        if (Date.now() - this.startTime > this.lambdaTimeout) {
+            const timeoutEventType = (0, helpers_1.getTimeoutExtractorEventType)(this.event.payload.event_type);
+            if (timeoutEventType !== null) {
+                const { eventType, isError } = timeoutEventType;
+                const err = isError ? { message: 'Lambda Timeout' } : undefined;
+                await this.emit(eventType, { error: err, artifacts: this._artifacts });
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.Adapter = Adapter;

package/dist/deprecated/common/helpers.d.ts

@@ -0,0 +1,7 @@
+import { EventType, ExtractorEventType } from '../../types/extraction';
+export declare function createFormData(preparedArtifact: any, fetchedObjects: object[] | object): FormData;
+export declare function getTimeoutExtractorEventType(eventType: EventType): {
+    eventType: ExtractorEventType;
+    isError: boolean;
+} | null;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/deprecated/common/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/deprecated/common/helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEvE,wBAAgB,cAAc,CAE5B,gBAAgB,EAAE,GAAG,EACrB,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,GAChC,QAAQ,CAUV;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,SAAS,GAAG;IAClE,SAAS,EAAE,kBAAkB,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,IAAI,CA+BP"}

package/dist/deprecated/common/helpers.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormData = createFormData;
+exports.getTimeoutExtractorEventType = getTimeoutExtractorEventType;
+const js_jsonl_1 = require("js-jsonl");
+const extraction_1 = require("../../types/extraction");
+function createFormData(
+//eslint-disable-next-line @typescript-eslint/no-explicit-any
+preparedArtifact, fetchedObjects) {
+    const formData = new FormData();
+    for (const item of preparedArtifact.form_data) {
+        formData.append(item.key, item.value);
+    }
+    const output = js_jsonl_1.jsonl.stringify(fetchedObjects);
+    formData.append('file', output);
+    return formData;
+}
+function getTimeoutExtractorEventType(eventType) {
+    switch (eventType) {
+        case extraction_1.EventType.ExtractionMetadataStart:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractionMetadataError,
+                isError: true,
+            };
+        case extraction_1.EventType.ExtractionDataStart:
+        case extraction_1.EventType.ExtractionDataContinue:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractionDataProgress,
+                isError: false,
+            };
+        case extraction_1.EventType.ExtractionAttachmentsStart:
+        case extraction_1.EventType.ExtractionAttachmentsContinue:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractionAttachmentsProgress,
+                isError: false,
+            };
+        case extraction_1.EventType.ExtractionExternalSyncUnitsStart:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsError,
+                isError: true,
+            };
+        default:
+            console.log('Event type not recognized in getTimeoutExtractorEventType function: ' +
+                eventType);
+            return null;
+    }
+}

package/dist/deprecated/demo-extractor/external_domain_metadata.json

@@ -0,0 +1,38 @@
+{
+    "record_types": {
+        "users": {
+            "fields": {
+                "name": {
+                    "is_required": true,
+                    "type": "text",
+                    "name": "Name",
+                    "text": {
+                        "min_length": 1
+                    }
+                },
+                "email": {
+                    "type": "text",
+                    "name": "Email",
+                    "is_required": true
+                }
+            }
+        },
+        "contacts": {
+            "fields": {
+                "name": {
+                    "is_required": true,
+                    "type": "text",
+                    "name": "Name",
+                    "text": {
+                        "min_length": 1
+                    }
+                },
+                "email": {
+                    "type": "text",
+                    "name": "Email",
+                    "is_required": true
+                }
+            }
+        }
+    }
+}

package/dist/deprecated/demo-extractor/index.d.ts

@@ -0,0 +1,18 @@
+import { AirdropEvent } from '../../types/extraction';
+import { Adapter } from '../adapter';
+type ConnectorState = object;
+/**
+ * Demo extractor is a reference implementation of an ADaaS connector to facilitate rapid immersion into ADaaS.
+ *
+ * @class DemoExtractor
+ * @deprecated
+ **/
+export declare class DemoExtractor {
+    private event;
+    private adapter;
+    private uploader;
+    constructor(event: AirdropEvent, adapter: Adapter<ConnectorState>);
+    run(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/deprecated/demo-extractor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deprecated/demo-extractor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAIb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAIrC,KAAK,cAAc,GAAG,MAAM,CAAC;AAE7B;;;;;IAKI;AACJ,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,QAAQ,CAAW;gBAEf,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC;IAS3D,GAAG;CA0MV"}

package/dist/deprecated/demo-extractor/index.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DemoExtractor = void 0;
+const extraction_1 = require("../../types/extraction");
+const uploader_1 = require("../uploader");
+const external_domain_metadata_json_1 = __importDefault(require("./external_domain_metadata.json"));
+/**
+ * Demo extractor is a reference implementation of an ADaaS connector to facilitate rapid immersion into ADaaS.
+ *
+ * @class DemoExtractor
+ * @deprecated
+ **/
+class DemoExtractor {
+    constructor(event, adapter) {
+        this.event = event;
+        this.adapter = adapter;
+        this.uploader = new uploader_1.Uploader(this.event.execution_metadata.devrev_endpoint, this.event.context.secrets.service_account_token);
+    }
+    async run() {
+        switch (this.event.payload.event_type) {
+            case extraction_1.EventType.ExtractionExternalSyncUnitsStart: {
+                const externalSyncUnits = [
+                    {
+                        id: 'devrev',
+                        name: 'devrev',
+                        description: 'Demo external sync unit',
+                    },
+                ];
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionExternalSyncUnitsDone, {
+                    external_sync_units: externalSyncUnits,
+                });
+                break;
+            }
+            case extraction_1.EventType.ExtractionMetadataStart: {
+                const { artifact, error } = await this.uploader.upload('metadata_1.jsonl', 'external_domain_metadata', external_domain_metadata_json_1.default);
+                if (error || !artifact) {
+                    await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionMetadataError, {
+                        error,
+                    });
+                    return;
+                }
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionMetadataDone, {
+                    artifacts: [artifact],
+                });
+                break;
+            }
+            case extraction_1.EventType.ExtractionDataStart: {
+                const contacts = [
+                    {
+                        id: 'contact-1',
+                        created_date: '1999-12-25T01:00:03+01:00',
+                        modified_date: '1999-12-25T01:00:03+01:00',
+                        data: {
+                            email: 'johnsmith@test.com',
+                            name: 'John Smith',
+                        },
+                    },
+                    {
+                        id: 'contact-2',
+                        created_date: '1999-12-27T15:31:34+01:00',
+                        modified_date: '2002-04-09T01:55:31+02:00',
+                        data: {
+                            email: 'janesmith@test.com',
+                            name: 'Jane Smith',
+                        },
+                    },
+                ];
+                const { artifact, error } = await this.uploader.upload('contacts_1.json', 'contacts', contacts);
+                if (error || !artifact) {
+                    await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionDataError, {
+                        error,
+                    });
+                    return;
+                }
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionDataProgress, {
+                    progress: 50,
+                    artifacts: [artifact],
+                });
+                break;
+            }
+            case extraction_1.EventType.ExtractionDataContinue: {
+                const users = [
+                    {
+                        id: 'user-1',
+                        created_date: '1999-12-25T01:00:03+01:00',
+                        modified_date: '1999-12-25T01:00:03+01:00',
+                        data: {
+                            email: 'johndoe@test.com',
+                            name: 'John Doe',
+                        },
+                    },
+                    {
+                        id: 'user-2',
+                        created_date: '1999-12-27T15:31:34+01:00',
+                        modified_date: '2002-04-09T01:55:31+02:00',
+                        data: {
+                            email: 'janedoe@test.com',
+                            name: 'Jane Doe',
+                        },
+                    },
+                ];
+                const { artifact, error } = await this.uploader.upload('users_1.json', 'users', users);
+                if (error || !artifact) {
+                    await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionDataError, {
+                        error,
+                    });
+                    return;
+                }
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionDataDone, {
+                    progress: 100,
+                    artifacts: [artifact],
+                });
+                break;
+            }
+            case extraction_1.EventType.ExtractionDataDelete: {
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionDataDeleteDone);
+                break;
+            }
+            case extraction_1.EventType.ExtractionAttachmentsStart: {
+                const attachment1 = ['This is attachment1.txt content'];
+                const { artifact, error } = await this.uploader.upload('attachment1.txt', 'attachment', attachment1);
+                if (error || !artifact) {
+                    await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionAttachmentsError, {
+                        error,
+                    });
+                    return;
+                }
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionAttachmentsProgress, {
+                    artifacts: [artifact],
+                });
+                break;
+            }
+            case extraction_1.EventType.ExtractionAttachmentsContinue: {
+                const attachment2 = ['This is attachment2.txt content'];
+                const { artifact, error } = await this.uploader.upload('attachment2.txt', 'attachment', attachment2);
+                if (error || !artifact) {
+                    await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionAttachmentsError, {
+                        error,
+                    });
+                    return;
+                }
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionAttachmentsDone, {
+                    artifacts: [artifact],
+                });
+                break;
+            }
+            case extraction_1.EventType.ExtractionAttachmentsDelete: {
+                await this.adapter.emit(extraction_1.ExtractorEventType.ExtractionAttachmentsDeleteDone);
+                break;
+            }
+            default: {
+                console.error('Event in DemoExtractor run not recognized: ' +
+                    JSON.stringify(this.event.payload.event_type));
+            }
+        }
+    }
+}
+exports.DemoExtractor = DemoExtractor;

package/dist/deprecated/http/client.d.ts

@@ -0,0 +1,22 @@
+import { RawAxiosRequestHeaders } from 'axios';
+import { HTTPResponse } from '../../http/types';
+export declare const defaultResponse: HTTPResponse;
+/**
+ * HTTPClient class to make HTTP requests
+ * @deprecated
+ */
+export declare class HTTPClient {
+    private retryAfter;
+    private retryAt;
+    private axiosInstance;
+    constructor();
+    /**
+     *
+     * Function to make a GET call to the endpoint.
+     * There is special handling for rate limit exceeded error.
+     * In case of rate limit exceeded, the function returns success as true and the delay time in seconds
+     * In case of any other error, the function returns success as false and the error message
+     */
+    getCall(endpoint: string, headers: RawAxiosRequestHeaders, params?: any): Promise<HTTPResponse>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/deprecated/http/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/deprecated/http/client.ts"],"names":[],"mappings":"AAAA,OAAc,EAGZ,sBAAsB,EACvB,MAAM,OAAO,CAAC;AAKf,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,eAAO,MAAM,eAAe,EAAE,YAQ7B,CAAC;AAEF;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,aAAa,CAAkB;;IA8BvC;;;;;;OAMG;IACG,OAAO,CACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,sBAAsB,EAE/B,MAAM,CAAC,EAAE,GAAG,GACX,OAAO,CAAC,YAAY,CAAC;CA8EzB"}

package/dist/deprecated/http/client.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPClient = exports.defaultResponse = void 0;
+const axios_1 = __importStar(require("axios"));
+const constants_1 = require("../../http/constants");
+exports.defaultResponse = {
+    data: {
+        delay: 0,
+        nextPage: 1,
+        records: [],
+    },
+    message: '',
+    success: false,
+};
+/**
+ * HTTPClient class to make HTTP requests
+ * @deprecated
+ */
+class HTTPClient {
+    constructor() {
+        this.retryAfter = 0;
+        this.retryAt = 0;
+        this.axiosInstance = axios_1.default.create();
+        // Add request interceptor to check for retryAfter before making a request
+        this.axiosInstance.interceptors.request.use((config) => {
+            // Check if retryAfter is not 0 and return a LIMIT_EXCEEDED error
+            if (this.retryAfter !== 0) {
+                // check if the current time is greater than the retryAt time
+                const currentTime = new Date().getTime();
+                if (currentTime < this.retryAt) {
+                    console.error('Rate limit exceeded. Interceptor has retryAfter: ' +
+                        this.retryAfter);
+                    // Rate limit exceeded.
+                    return Promise.reject(constants_1.RATE_LIMIT_EXCEEDED);
+                }
+                else {
+                    // Reset the retryAfter
+                    this.retryAfter = 0;
+                }
+            }
+            return config;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+    }
+    /**
+     *
+     * Function to make a GET call to the endpoint.
+     * There is special handling for rate limit exceeded error.
+     * In case of rate limit exceeded, the function returns success as true and the delay time in seconds
+     * In case of any other error, the function returns success as false and the error message
+     */
+    async getCall(endpoint, headers, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params) {
+        var _a;
+        // Return the LIMIT_EXCEEDED error if the retryAfter is not 0
+        try {
+            const res = await this.axiosInstance.get(endpoint, {
+                headers: headers,
+                params: params,
+            });
+            return Object.assign(Object.assign({}, exports.defaultResponse), { data: {
+                    delay: 0,
+                    records: res.data,
+                }, success: true });
+        }
+        catch (error) {
+            console.log('Error in getCall: ' + JSON.stringify(error));
+            // send error to adapter
+            if ((0, axios_1.isAxiosError)(error)) {
+                if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === constants_1.RATE_LIMIT_EXCEEDED_STATUS_CODE) {
+                    this.retryAfter = error.response.headers['retry-after']
+                        ? error.response.headers['retry-after']
+                        : 0;
+                    this.retryAt = new Date().getTime() + this.retryAfter * 1000;
+                    console.warn('Rate limit exceeded. Error code: ' +
+                        error.response.status +
+                        ' RetryAfter: ' +
+                        this.retryAfter +
+                        ' RetryAt: ' +
+                        this.retryAt);
+                    return {
+                        data: {
+                            delay: this.retryAfter,
+                            records: [],
+                        },
+                        message: constants_1.RATE_LIMIT_EXCEEDED,
+                        success: true,
+                    };
+                }
+                if (error.response) {
+                    return Object.assign(Object.assign({}, exports.defaultResponse), { message: error.response.data });
+                }
+                else {
+                    return Object.assign(Object.assign({}, exports.defaultResponse), { message: error.message });
+                }
+            }
+            else {
+                if (this.retryAfter !== 0) {
+                    console.warn('Rate limit exceeded. Going to return the following response: ' +
+                        JSON.stringify(error));
+                    return {
+                        data: {
+                            delay: this.retryAfter,
+                            records: [],
+                        },
+                        message: typeof error === 'string'
+                            ? error
+                            : JSON.stringify(error, Object.getOwnPropertyNames(error)),
+                        success: true,
+                    };
+                }
+                return {
+                    data: {
+                        delay: this.retryAfter,
+                        records: [],
+                    },
+                    message: typeof error === 'string'
+                        ? error
+                        : JSON.stringify(error, Object.getOwnPropertyNames(error)),
+                    success: false,
+                };
+            }
+        }
+    }
+}
+exports.HTTPClient = HTTPClient;

package/dist/deprecated/uploader/index.d.ts

@@ -0,0 +1,35 @@
+import { UploadResponse } from '../../uploader/uploader.interfaces';
+/**
+ * Uploader class is used to upload files to the DevRev platform.
+ * The class provides utilities to
+ * - prepare artifact
+ * - upload artifact
+ * - return the artifact information to the platform
+ *
+ * @class Uploader
+ * @constructor
+ * @param {string} endpoint - The endpoint of the DevRev platform
+ * @param {string} token - The token to authenticate with the DevRev platform
+ * @param {boolean} local - Flag to indicate if the uploader should upload to the file-system.
+ */
+export declare class Uploader {
+    private betaDevrevSdk;
+    private local;
+    constructor(endpoint: string, token: string, local?: boolean);
+    /**
+     *
+     *  Uploads the file to the DevRev platform. The file is uploaded to the platform
+     *  and the artifact information is returned.
+     *
+     * @param {string} filename - The name of the file to be uploaded
+     * @param {string} entity - The entity type of the file to be uploaded
+     * @param {object[] | object} fetchedObjects - The objects to be uploaded
+     * @param filetype - The type of the file to be uploaded
+     * @returns {Promise<UploadResponse>} - The response object containing the artifact information
+     */
+    upload(filename: string, entity: string, fetchedObjects: object[] | object, filetype?: string): Promise<UploadResponse>;
+    private prepareArtifact;
+    private uploadToArtifact;
+    private downloadToLocal;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/deprecated/uploader/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deprecated/uploader/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAY,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAG9E;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,KAAK,CAAU;gBACX,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,UAAQ;IAQ1D;;;;;;;;;;OAUG;IACG,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,EACjC,QAAQ,GAAE,MAAiC,GAC1C,OAAO,CAAC,cAAc,CAAC;YAuCZ,eAAe;YAiBf,gBAAgB;YAqBhB,eAAe;CAgC9B"}