@devrev/ts-adaas 0.0.3 → 1.0.0

package/dist/types/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = exports.ErrorLevel = void 0;
+// Common
+var common_1 = require("./common");
+Object.defineProperty(exports, "ErrorLevel", { enumerable: true, get: function () { return common_1.ErrorLevel; } });
+// Extraction
+var extraction_1 = require("./extraction");
+Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return extraction_1.EventType; } });
+Object.defineProperty(exports, "ExtractorEventType", { enumerable: true, get: function () { return extraction_1.ExtractorEventType; } });
+Object.defineProperty(exports, "ExtractionMode", { enumerable: true, get: function () { return extraction_1.ExtractionMode; } });

package/dist/types/workers.d.ts

@@ -0,0 +1,142 @@
+import { Worker } from 'worker_threads';
+import { MessagePort } from 'node:worker_threads';
+import { State } from '../state/state';
+import { WorkerAdapter } from '../workers/worker-adapter';
+import { ExtractorEventType, AirdropEvent } from './extraction';
+/**
+ * WorkerAdapterInterface is an interface for WorkerAdapter class.
+ * @interface WorkerAdapterInterface
+ * @constructor
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param {object=} initialState - The initial state of the adapter
+ * @param {MessagePort} parentPort - The parent port of the worker thread
+ * @param {WorkerAdapterInterface} options - The options to create a new instance of WorkerAdapter class
+ */
+export interface WorkerAdapterInterface<ConnectorState> {
+    event: AirdropEvent;
+    adapterState: State<ConnectorState>;
+    parentPort: MessagePort;
+    options: WorkerAdapterOptions;
+}
+/**
+ * WorkerAdapterOptions represents the options for WorkerAdapter class.
+ * @interface WorkerAdapterOptions
+ * @constructor
+ * @param {boolean=} isLocalDevelopment - A flag to indicate if the adapter is being used in local development
+ * @param {number=} timeout - The timeout for the worker thread
+ */
+export interface WorkerAdapterOptions {
+    isLocalDevelopment?: boolean;
+    timeout?: number;
+}
+export type SpawnResolve = (value: boolean | PromiseLike<boolean>) => void;
+/**
+ * SpawnInterface is an interface for Spawn class.
+ * @interface SpawnInterface
+ * @constructor
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param {Worker} worker - The worker thread
+ */
+export interface SpawnInterface {
+    event: AirdropEvent;
+    worker: Worker;
+    options: WorkerAdapterOptions | null;
+    resolve: SpawnResolve;
+}
+/**
+ * SpawnFactoryInterface is an interface for Spawn class factory.
+ * Spawn class is responsible for spawning a new worker thread and managing the lifecycle of the worker.
+ * The class provides utilities to emit control events to the platform and exit the worker gracefully.
+ * In case of lambda timeout, the class emits a lambda timeout event to the platform.
+ * @interface SpawnFactoryInterface
+ * @constructor
+ * @param {AirdropEvent} event - The event object received from the platform
+ * @param {object=} initialState - The initial state of the adapter
+ * @param {string} workerPath - The path to the worker file
+ * @param {WorkerAdapterOptions} options - The options to create a new instance of Spawn class
+ */
+export interface SpawnFactoryInterface<ConnectorState> {
+    event: AirdropEvent;
+    initialState: ConnectorState;
+    workerPath?: string;
+    options?: WorkerAdapterOptions;
+}
+/**
+ * TaskAdapterInterface is an interface for TaskAdapter class.
+ * @interface TaskAdapterInterface
+ * @constructor
+ * @param {WorkerAdapter} adapter - The adapter object
+ */
+export interface TaskAdapterInterface<ConnectorState> {
+    adapter: WorkerAdapter<ConnectorState>;
+}
+/**
+ * ProcessTaskInterface is an interface for ProcessTask class.
+ * @interface ProcessTaskInterface
+ * @constructor
+ * @param {function} task - The task to be executed, returns exit code
+ * @param {function} onTimeout - The task to be executed on timeout, returns exit code
+ */
+export interface ProcessTaskInterface<ConnectorState> {
+    task: (params: TaskAdapterInterface<ConnectorState>) => void;
+    onTimeout: (params: TaskAdapterInterface<ConnectorState>) => void;
+}
+/**
+ * WorkerEvent represents the standard worker events.
+ */
+export declare enum WorkerEvent {
+    WorkerMessage = "message",
+    WorkerOnline = "online",
+    WorkerError = "error",
+    WorkerExit = "exit"
+}
+/**
+ * WorkerMessageSubject represents the handled worker message subjects.
+ */
+export declare enum WorkerMessageSubject {
+    WorkerMessageEmitted = "emit",
+    WorkerMessageDone = "done",
+    WorkerMessageExit = "exit",
+    WorkerMessageLog = "log"
+}
+/**
+ * WorkerMessageEmitted interface represents the structure of the emitted worker message.
+ */
+export interface WorkerMessageEmitted {
+    subject: WorkerMessageSubject.WorkerMessageEmitted;
+    payload: {
+        eventType: ExtractorEventType;
+    };
+}
+/**
+ * WorkerMessageDone interface represents the structure of the done worker message.
+ */
+export interface WorkerMessageDone {
+    subject: WorkerMessageSubject.WorkerMessageDone;
+}
+/**
+ * WorkerMessageExit interface represents the structure of the exit worker message.
+ */
+export interface WorkerMessageExit {
+    subject: WorkerMessageSubject.WorkerMessageExit;
+}
+/**
+ * WorkerMessage represents the structure of the worker message.
+ */
+export type WorkerMessage = WorkerMessageDone | WorkerMessageEmitted | WorkerMessageExit;
+/**
+ * WorkerData represents the structure of the worker data object.
+ */
+export interface WorkerData<ConnectorState> {
+    event: AirdropEvent;
+    initialState: ConnectorState;
+    workerPath: string;
+    options?: WorkerAdapterOptions;
+}
+/**
+ * GetWorkerPathInterface is an interface for getting the worker path.
+ */
+export interface GetWorkerPathInterface {
+    event: AirdropEvent;
+    connectorWorkerPath?: string | null;
+}

package/dist/types/workers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageSubject = exports.WorkerEvent = void 0;
+/**
+ * WorkerEvent represents the standard worker events.
+ */
+var WorkerEvent;
+(function (WorkerEvent) {
+    WorkerEvent["WorkerMessage"] = "message";
+    WorkerEvent["WorkerOnline"] = "online";
+    WorkerEvent["WorkerError"] = "error";
+    WorkerEvent["WorkerExit"] = "exit";
+})(WorkerEvent || (exports.WorkerEvent = WorkerEvent = {}));
+/**
+ * WorkerMessageSubject represents the handled worker message subjects.
+ */
+var WorkerMessageSubject;
+(function (WorkerMessageSubject) {
+    WorkerMessageSubject["WorkerMessageEmitted"] = "emit";
+    WorkerMessageSubject["WorkerMessageDone"] = "done";
+    WorkerMessageSubject["WorkerMessageExit"] = "exit";
+    WorkerMessageSubject["WorkerMessageLog"] = "log";
+})(WorkerMessageSubject || (exports.WorkerMessageSubject = WorkerMessageSubject = {}));

package/dist/uploader/uploader.d.ts

@@ -0,0 +1,38 @@
+import { UploadResponse, StreamAttachmentsResponse, UploaderFactoryInterface } from './uploader.interfaces';
+export declare class Uploader {
+    private event;
+    private betaDevrevSdk;
+    private isLocalDevelopment?;
+    constructor({ event, options }: UploaderFactoryInterface);
+    /**
+     * Uploads the fetched objects to the DevRev platform.
+     * The fetched objects are uploaded to the platform and the artifact information is returned.
+     * @param {string} filename - The name of the file to be uploaded
+     * @param {string} itemType - The type of the item to be uploaded
+     * @param {object[] | object} fetchedObjects - The fetched objects to be uploaded
+     * @returns {Promise<UploadResponse>} - The response object containing the artifact information
+     * or error information if there was an error
+     */
+    upload(itemType: string, fetchedObjects: object[] | object): Promise<UploadResponse>;
+    private prepareArtifact;
+    private uploadToArtifact;
+    private streamToArtifact;
+    /**
+     * Streams the attachments to the DevRev platform.
+     * The attachments are streamed to the platform and the artifact information is returned.
+     * @param {string} attachmentsMetadataArtifactId - The artifact ID of the attachments metadata
+     * @returns {Promise<UploadResponse>} - The response object containing the ssoAttachment artifact information
+     * or error information if there was an error
+     */
+    streamAttachments({ attachmentsMetadataArtifactId, }: {
+        attachmentsMetadataArtifactId: string;
+    }): Promise<StreamAttachmentsResponse>;
+    private getArtifactDownloadUrl;
+    private downloadArtifact;
+    private compressGzip;
+    private decompressGzip;
+    private parseJsonl;
+    private stream;
+    private getFileStreamResponse;
+    private downloadToLocal;
+}

package/dist/uploader/uploader.interfaces.d.ts

@@ -0,0 +1,63 @@
+import { AirdropEvent } from '../types/extraction';
+import { WorkerAdapterOptions } from '../types/workers';
+import { ErrorRecord } from '../types/common';
+export interface UploaderFactoryInterface {
+    event: AirdropEvent;
+    options?: WorkerAdapterOptions;
+}
+/**
+ * Artifact is an interface that defines the structure of an artifact. Artifact is a file that is generated by the extractor and uploaded to ADaaS.
+ */
+export interface Artifact {
+    id: string;
+    item_type: string;
+    item_count: number;
+}
+/**
+ * ArtifactsPrepareResponse is an interface that defines the structure of the response from the prepare artifacts endpoint.
+ * @deprecated
+ */
+export interface ArtifactsPrepareResponse {
+    url: string;
+    id: string;
+    form_data: {
+        key: string;
+        value: string;
+    }[];
+}
+/**
+ * UploadResponse is an interface that defines the structure of the response from upload through Uploader.
+ */
+export interface UploadResponse {
+    artifact?: Artifact;
+    error?: ErrorRecord;
+}
+/**
+ * StreamAttachmentsResponse is an interface that defines the structure of the response from the stream attachments through Uploader.
+ */
+export interface StreamAttachmentsResponse {
+    ssorAttachments?: SsorAttachment[];
+    error?: ErrorRecord;
+}
+/**
+ * StreamResponse is an interface that defines the structure of the response from the stream of single attachment through Uploader.
+ */
+export interface StreamResponse {
+    ssorAttachment?: SsorAttachment;
+    error?: ErrorRecord;
+}
+/**
+ * SsorAttachment is an interface that defines the structure of the SSOR attachment.
+ */
+export interface SsorAttachment {
+    id: {
+        devrev: string;
+        external: string;
+    };
+    parent_id: {
+        external: string;
+    };
+    actor_id: {
+        external: string;
+    };
+}

package/dist/uploader/uploader.interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/uploader/uploader.js

@@ -0,0 +1,351 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uploader = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importStar(require("fs"));
+const zlib_1 = __importDefault(require("zlib"));
+const js_jsonl_1 = require("js-jsonl");
+const form_data_1 = __importDefault(require("form-data"));
+const typescript_sdk_1 = require("@devrev/typescript-sdk");
+const constants_1 = require("../common/constants");
+const logger_1 = require("../logger/logger");
+class Uploader {
+    constructor({ event, options }) {
+        this.event = event;
+        this.betaDevrevSdk = typescript_sdk_1.client.setupBeta({
+            endpoint: event.execution_metadata.devrev_endpoint,
+            token: event.context.secrets.service_account_token,
+        });
+        this.isLocalDevelopment = options === null || options === void 0 ? void 0 : options.isLocalDevelopment;
+    }
+    /**
+     * Uploads the fetched objects to the DevRev platform.
+     * The fetched objects are uploaded to the platform and the artifact information is returned.
+     * @param {string} filename - The name of the file to be uploaded
+     * @param {string} itemType - The type of the item to be uploaded
+     * @param {object[] | object} fetchedObjects - The fetched objects to be uploaded
+     * @returns {Promise<UploadResponse>} - The response object containing the artifact information
+     * or error information if there was an error
+     */
+    async upload(itemType, fetchedObjects) {
+        if (this.isLocalDevelopment) {
+            this.downloadToLocal(itemType, fetchedObjects);
+        }
+        // 1. Compress the fetched objects to a gzipped jsonl object
+        const file = await this.compressGzip(js_jsonl_1.jsonl.stringify(fetchedObjects));
+        if (!file) {
+            return {
+                error: { message: 'Error while compressing jsonl object.' },
+            };
+        }
+        const filename = itemType + '.jsonl.gz';
+        const fileType = 'application/x-gzip';
+        // 2. Prepare the artifact for uploading
+        const preparedArtifact = await this.prepareArtifact(filename, fileType);
+        if (!preparedArtifact) {
+            return {
+                error: { message: 'Error while preparing artifact.' },
+            };
+        }
+        // 3. Upload the file to the prepared artifact
+        const uploadedArtifact = await this.uploadToArtifact(preparedArtifact, file);
+        if (!uploadedArtifact) {
+            return {
+                error: { message: 'Error while uploading artifact.' },
+            };
+        }
+        // 4. Return the artifact information to the platform
+        const artifact = {
+            id: preparedArtifact.id,
+            item_type: itemType,
+            item_count: Array.isArray(fetchedObjects) ? fetchedObjects.length : 1,
+        };
+        console.log('Successful upload of artifact: ', artifact);
+        return { artifact };
+    }
+    async prepareArtifact(filename, fileType) {
+        try {
+            const response = await this.betaDevrevSdk.artifactsPrepare({
+                file_name: filename,
+                file_type: fileType,
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                console.error('Error while preparing artifact.', (0, logger_1.formatAxiosError)(error));
+            }
+            else {
+                console.error('Error while preparing artifact.', error);
+            }
+        }
+    }
+    async uploadToArtifact(preparedArtifact, file
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        const formData = new form_data_1.default();
+        for (const field of preparedArtifact.form_data) {
+            formData.append(field.key, field.value);
+        }
+        formData.append('file', file);
+        try {
+            const response = await axios_1.default.post(preparedArtifact.url, formData, {
+                headers: Object.assign({}, formData.getHeaders()),
+            });
+            return response;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                console.error('Error while uploading artifact.', (0, logger_1.formatAxiosError)(error));
+            }
+            else {
+                console.error('Error while uploading artifact.', error);
+            }
+        }
+    }
+    async streamToArtifact(preparedArtifact, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fileStreamResponse) {
+        const formData = new form_data_1.default();
+        for (const field of preparedArtifact.form_data) {
+            formData.append(field.key, field.value);
+        }
+        formData.append('file', fileStreamResponse.data);
+        try {
+            const response = await axios_1.default.post(preparedArtifact.url, formData, {
+                headers: Object.assign(Object.assign({}, formData.getHeaders()), (!fileStreamResponse.headers['content-length'] && {
+                    'Content-Length': constants_1.MAX_DEVREV_ARTIFACT_SIZE,
+                })),
+            });
+            return response;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                console.error('Error while streaming artifact.', (0, logger_1.formatAxiosError)(error));
+            }
+            else {
+                console.error('Error while streaming artifact.', error);
+            }
+            return;
+        }
+    }
+    /**
+     * Streams the attachments to the DevRev platform.
+     * The attachments are streamed to the platform and the artifact information is returned.
+     * @param {string} attachmentsMetadataArtifactId - The artifact ID of the attachments metadata
+     * @returns {Promise<UploadResponse>} - The response object containing the ssoAttachment artifact information
+     * or error information if there was an error
+     */
+    async streamAttachments({ attachmentsMetadataArtifactId, }) {
+        console.log('Started streaming attachments to the platform.');
+        // 1. Get the URL of the attachments metadata artifact
+        const artifactUrl = await this.getArtifactDownloadUrl(attachmentsMetadataArtifactId);
+        if (!artifactUrl) {
+            return {
+                error: { message: 'Error while getting artifact download URL.' },
+            };
+        }
+        // 2. Download artifact from the URL
+        const gzippedJsonlObject = await this.downloadArtifact(artifactUrl);
+        if (!gzippedJsonlObject) {
+            return {
+                error: { message: 'Error while downloading gzipped jsonl object.' },
+            };
+        }
+        // 3. Decompress the gzipped jsonl object
+        const jsonlObject = await this.decompressGzip(gzippedJsonlObject);
+        if (!jsonlObject) {
+            return {
+                error: { message: 'Error while decompressing gzipped jsonl object.' },
+            };
+        }
+        // 4. Parse the jsonl object to get the attachment metadata
+        const jsonObject = (await this.parseJsonl(jsonlObject));
+        if (!jsonObject) {
+            return {
+                error: { message: 'Error while parsing jsonl object.' },
+            };
+        }
+        // 5. Stream each attachment to the platform, and push the ssorAttachment to the ssorAttachments array
+        const ssorAttachments = [];
+        for (const attachmentMetadata of jsonObject) {
+            const { ssorAttachment, error } = await this.stream(attachmentMetadata);
+            if (error || !ssorAttachment) {
+                console.warn('Error while streaming attachment', error);
+                continue;
+            }
+            ssorAttachments.push(ssorAttachment);
+        }
+        if (!ssorAttachments.length) {
+            console.warn('No attachments were streamed to the platform.');
+            return {
+                error: { message: 'No attachments were streamed to the platform.' },
+            };
+        }
+        return { ssorAttachments };
+    }
+    async getArtifactDownloadUrl(artifactId) {
+        try {
+            const response = await this.betaDevrevSdk.artifactsLocate({
+                id: artifactId,
+            });
+            return response.data.url;
+        }
+        catch (error) {
+            console.error('Error while getting artifact download URL.', error);
+        }
+    }
+    async downloadArtifact(artifactUrl) {
+        try {
+            const response = await axios_1.default.get(artifactUrl, {
+                responseType: 'arraybuffer',
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                console.error('Error while downloading artifact from URL.', (0, logger_1.formatAxiosError)(error));
+            }
+            else {
+                console.error('Error while downloading artifact from URL.', error);
+            }
+        }
+    }
+    async compressGzip(jsonlObject) {
+        try {
+            return zlib_1.default.gzipSync(jsonlObject);
+        }
+        catch (error) {
+            console.error('Error while compressing jsonl object.', error);
+        }
+    }
+    async decompressGzip(gzippedJsonlObject) {
+        try {
+            const jsonlObject = await zlib_1.default.gunzipSync(gzippedJsonlObject);
+            return jsonlObject.toString();
+        }
+        catch (error) {
+            console.error('Error while decompressing gzipped jsonl object.', error);
+        }
+    }
+    async parseJsonl(jsonlObject) {
+        try {
+            return js_jsonl_1.jsonl.parse(jsonlObject);
+        }
+        catch (error) {
+            console.error('Error while parsing jsonl object.', error);
+        }
+    }
+    async stream(attachmentMetadata) {
+        var _a;
+        const { id: externalId, file_name: filename, url, parent_id: parentId, author_id: actorId, } = attachmentMetadata;
+        const fileStreamResponse = await this.getFileStreamResponse(url);
+        if (!fileStreamResponse) {
+            return {
+                error: { message: 'Error while fetching attachment from URL' },
+            };
+        }
+        const fileType = ((_a = fileStreamResponse.headers) === null || _a === void 0 ? void 0 : _a['content-type']) ||
+            'application/octet-stream';
+        const preparedArtifact = await this.prepareArtifact(filename, fileType);
+        if (!preparedArtifact) {
+            return {
+                error: { message: 'Error while preparing artifact.' },
+            };
+        }
+        const uploadedArtifact = await this.streamToArtifact(preparedArtifact, fileStreamResponse);
+        if (!uploadedArtifact) {
+            return {
+                error: { message: 'Error while streaming artifact.' },
+            };
+        }
+        const ssorAttachment = {
+            id: {
+                devrev: preparedArtifact.id,
+                external: externalId,
+            },
+            parent_id: {
+                external: parentId,
+            },
+            actor_id: {
+                external: actorId,
+            },
+        };
+        console.log('Successful stream of attachment: ', ssorAttachment);
+        return { ssorAttachment };
+    }
+    async getFileStreamResponse(url) {
+        try {
+            const fileStreamResponse = await axios_1.default.get(url, {
+                responseType: 'stream',
+                headers: {
+                    Authorization: this.event.payload.connection_data.key,
+                },
+            });
+            return fileStreamResponse;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                console.error('Error while fetching attachment from URL.', (0, logger_1.formatAxiosError)(error));
+            }
+            else {
+                console.error('Error while fetching attachment from URL.', error);
+            }
+        }
+    }
+    async downloadToLocal(itemType, fetchedObjects) {
+        console.log(`Downloading ${itemType} to local file system.`);
+        try {
+            if (!fs_1.default.existsSync('extracted_files')) {
+                fs_1.default.mkdirSync('extracted_files');
+            }
+            const timestamp = new Date().getTime();
+            const filePath = `extracted_files/extractor_${itemType}_${timestamp}.${itemType === 'external_domain_metadata' ? 'json' : 'jsonl'}`;
+            const fileHandle = await fs_1.promises.open(filePath, 'w');
+            let objArray = [];
+            if (!Array.isArray(fetchedObjects)) {
+                objArray.push(fetchedObjects);
+            }
+            else {
+                objArray = fetchedObjects;
+            }
+            for (const jsonObject of objArray) {
+                const jsonLine = JSON.stringify(jsonObject) + '\n';
+                await fileHandle.write(jsonLine);
+            }
+            await fileHandle.close();
+            console.log('Data successfully written to', filePath);
+        }
+        catch (error) {
+            console.error('Error writing data to file.', error);
+            return Promise.reject(error);
+        }
+    }
+}
+exports.Uploader = Uploader;

package/dist/{tests → uploader}/uploader.test.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const uploader_1 = require("../src/uploader");
+const test_helpers_1 = require("../tests/test-helpers");
+const types_1 = require("../types");
+const uploader_1 = require("./uploader");
 // mock uploader.upload method
-jest.mock('../src/uploader', () => {
+jest.mock('./uploader', () => {
     return {
         Uploader: jest.fn().mockImplementation(() => {
             return {
@@ -15,12 +17,12 @@ jest.mock('../src/uploader', () => {
     };
 });
 describe('uploader.ts', () => {
-    const uploader = new uploader_1.Uploader('https://example.com', 'test-token', false);
+    const mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.ExtractionDataStart });
+    const uploader = new uploader_1.Uploader({ event: mockEvent });
     it('should upload the file to the DevRev platform and return the artifact information', async () => {
-        const filename = 'filename';
         const entity = 'entity';
         const fetchedObjects = [{ key: 'value' }];
-        const uploadResponse = await uploader.upload(filename, entity, fetchedObjects);
+        const uploadResponse = await uploader.upload(entity, fetchedObjects);
         expect(uploadResponse).toEqual({
             artifact: { key: 'value' },
             error: undefined,

package/dist/workers/create-worker.d.ts

@@ -0,0 +1,4 @@
+import { Worker } from 'node:worker_threads';
+import { WorkerData } from '../types/workers';
+declare function createWorker<ConnectorState>(workerData: WorkerData<ConnectorState>): Promise<Worker>;
+export { createWorker };