@devrev/ts-adaas 0.0.2 → 1.0.0

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 };

package/dist/workers/create-worker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorker = createWorker;
+const node_worker_threads_1 = require("node:worker_threads");
+const workers_1 = require("../types/workers");
+const logger_1 = require("../logger/logger");
+async function createWorker(workerData) {
+    return new Promise((resolve, reject) => {
+        if (node_worker_threads_1.isMainThread) {
+            const logger = new logger_1.Logger(workerData.event);
+            const workerFile = __dirname + '/worker.js';
+            const worker = new node_worker_threads_1.Worker(workerFile, {
+                workerData,
+            });
+            worker.on(workers_1.WorkerEvent.WorkerError, (error) => {
+                logger.error('Worker error', error);
+                reject(error);
+            });
+            worker.on(workers_1.WorkerEvent.WorkerOnline, () => {
+                resolve(worker);
+                logger.info('Worker is online. Started processing the task with event type: ' +
+                    workerData.event.payload.event_type +
+                    '.');
+            });
+        }
+        else {
+            reject(new Error('Worker threads can not start more worker threads.'));
+        }
+    });
+}

package/dist/workers/create-worker.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const test_helpers_1 = require("../tests/test-helpers");
+const extraction_1 = require("../types/extraction");
+const create_worker_1 = require("./create-worker");
+describe('createWorker function', () => {
+    it('should return a Worker instance when a valid worker script is found', async () => {
+        const workerPath = __dirname + '../tests/dummy-worker.ts';
+        const worker = worker_threads_1.isMainThread
+            ? await (0, create_worker_1.createWorker)({
+                event: (0, test_helpers_1.createEvent)({
+                    eventType: extraction_1.EventType.ExtractionExternalSyncUnitsStart,
+                }),
+                initialState: {},
+                workerPath,
+            })
+            : null;
+        expect(worker).not.toBeNull();
+        expect(worker).toBeInstanceOf(worker_threads_1.Worker);
+        if (worker) {
+            await worker.terminate();
+        }
+    });
+});

package/dist/workers/default-workers/attachments-deletion.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/default-workers/attachments-deletion.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionAttachmentsDeleteDone);
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionAttachmentsDeleteError, {
+            error: { message: 'Failed to delete attachments. Lambda timeout.' },
+        });
+    },
+});

package/dist/workers/default-workers/attachments-extraction.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/default-workers/attachments-extraction.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+const uploader_1 = require("../../uploader/uploader");
+const repos = [
+    {
+        itemType: 'ssor_attachment',
+    },
+];
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        var _a, _b, _c, _d, _e;
+        if (!((_a = adapter.state.toDevRev) === null || _a === void 0 ? void 0 : _a.attachmentsMetadata.artifactIds) ||
+            adapter.state.toDevRev.attachmentsMetadata.artifactIds.length === 0) {
+            console.log('No attachments to extract, skipping.');
+            await adapter.emit(index_1.ExtractorEventType.ExtractionAttachmentsDone);
+            return;
+        }
+        adapter.initializeRepos(repos);
+        const uploader = new uploader_1.Uploader({
+            event: adapter.event,
+            options: adapter.options,
+        });
+        for (const attachmentsMetadataArtifactId of (_b = adapter.state.toDevRev) === null || _b === void 0 ? void 0 : _b.attachmentsMetadata.artifactIds) {
+            const { ssorAttachments, error } = await uploader.streamAttachments({
+                attachmentsMetadataArtifactId,
+            });
+            if (error || !ssorAttachments) {
+                await adapter.emit(index_1.ExtractorEventType.ExtractionAttachmentsError, {
+                    error,
+                });
+                return;
+            }
+            await ((_c = adapter.getRepo('ssor_attachment')) === null || _c === void 0 ? void 0 : _c.push(ssorAttachments));
+            (_d = adapter.state.toDevRev) === null || _d === void 0 ? void 0 : _d.attachmentsMetadata.artifactIds.shift();
+            adapter.state.toDevRev.attachmentsMetadata.lastProcessed = 0;
+            if (((_e = adapter.state.toDevRev) === null || _e === void 0 ? void 0 : _e.attachmentsMetadata.artifactIds.length) === 0) {
+                break;
+            }
+        }
+        await adapter.emit(index_1.ExtractorEventType.ExtractionAttachmentsDone);
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.postState();
+        await adapter.emit(index_1.ExtractorEventType.ExtractionAttachmentsProgress, {
+            progress: 50,
+        });
+    },
+});

package/dist/workers/default-workers/data-deletion.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/default-workers/data-deletion.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataDeleteDone);
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataDeleteError, {
+            error: {
+                message: 'Failed to delete data. Lambda timeout.',
+            },
+        });
+    },
+});

package/dist/workers/default-workers/data-extraction.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/default-workers/data-extraction.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+const data_normalization_1 = require("../dummy-extractor/data-normalization");
+// Dummy data that originally would be fetched from an external source
+const issues = [
+    {
+        id: 'issue-1',
+        created_date: '1999-12-25T01:00:03+01:00',
+        modified_date: '1999-12-25T01:00:03+01:00',
+        body: '<p>This is issue 1</p>',
+        creator: 'user-1',
+        owner: 'user-1',
+        title: 'Issue 1',
+    },
+    {
+        id: 'issue-2',
+        created_date: '1999-12-27T15:31:34+01:00',
+        modified_date: '2002-04-09T01:55:31+02:00',
+        body: '<p>This is issue 2</p>',
+        creator: 'user-2',
+        owner: 'user-2',
+        title: 'Issue 2',
+    },
+];
+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 attachments = [
+    {
+        url: 'https://app.dev.devrev-eng.ai/favicon.ico',
+        id: 'attachment-1',
+        file_name: 'dummy.jpg',
+        author_id: 'user-1',
+        parent_id: 'issue-1',
+    },
+    {
+        url: 'https://app.dev.devrev-eng.ai/favicon.ico',
+        id: 'attachment-2',
+        file_name: 'dummy.ico',
+        author_id: 'user-2',
+        parent_id: 'issue-2',
+    },
+];
+const repos = [
+    {
+        itemType: 'issues',
+        normalize: data_normalization_1.normalizeIssue,
+    },
+    {
+        itemType: 'users',
+        normalize: data_normalization_1.normalizeUser,
+    },
+    {
+        itemType: 'attachments',
+        normalize: data_normalization_1.normalizeAttachment,
+    },
+];
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        var _a, _b, _c;
+        console.log('Logging something from worker thread', {});
+        adapter.initializeRepos(repos);
+        if (adapter.event.payload.event_type === index_1.EventType.ExtractionDataStart) {
+            await ((_a = adapter.getRepo('issues')) === null || _a === void 0 ? void 0 : _a.push(issues));
+            await adapter.emit(index_1.ExtractorEventType.ExtractionDataProgress, {
+                progress: 50,
+            });
+        }
+        else {
+            await ((_b = adapter.getRepo('users')) === null || _b === void 0 ? void 0 : _b.push(users));
+            await ((_c = adapter.getRepo('attachments')) === null || _c === void 0 ? void 0 : _c.push(attachments));
+            await adapter.emit(index_1.ExtractorEventType.ExtractionDataDone, {
+                progress: 100,
+            });
+        }
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.postState();
+        await adapter.emit(index_1.ExtractorEventType.ExtractionDataProgress, {
+            progress: 50,
+        });
+    },
+});

package/dist/workers/default-workers/external-sync-units-extraction.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workers/default-workers/external-sync-units-extraction.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+// Dummy data that originally would be fetched from an external source
+const externalSyncUnits = [
+    {
+        id: 'devrev',
+        name: 'devrev',
+        description: 'Demo external sync unit',
+        item_count: 2,
+        item_type: 'issues',
+    },
+];
+(0, index_1.processTask)({
+    task: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionExternalSyncUnitsDone, {
+            external_sync_units: externalSyncUnits,
+        });
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.emit(index_1.ExtractorEventType.ExtractionExternalSyncUnitsError, {
+            error: {
+                message: 'Failed to extract external sync units. Lambda timeout.',
+            },
+        });
+    },
+});

package/dist/workers/default-workers/metadata-extraction.d.ts

@@ -0,0 +1 @@
+export {};