@devrev/airsync-sdk 2.0.0-beta.0

package/dist/multithreading/worker-adapter/worker-adapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-adapter.test.d.ts.map

package/dist/multithreading/worker-adapter/worker-adapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-adapter.test.d.ts","sourceRoot":"","sources":["../../../src/multithreading/worker-adapter/worker-adapter.test.ts"],"names":[],"mappings":""}

package/dist/multithreading/worker-adapter/worker-adapter.test.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const attachments_streaming_pool_1 = require("../../attachments-streaming/attachments-streaming-pool");
+const state_1 = require("../../state/state");
+const test_helpers_1 = require("../../tests/test-helpers");
+const types_1 = require("../../types");
+const worker_adapter_1 = require("./worker-adapter");
+/* eslint-disable @typescript-eslint/no-require-imports */
+// Mock dependencies
+jest.mock('../../common/control-protocol', () => ({
+    emit: jest.fn().mockResolvedValue({}),
+}));
+// const mockPostState = jest.spyOn(State.prototype, 'postState').mockResolvedValue(); // Mock to resolve void
+// const mockFetchState = jest.spyOn(State.prototype, 'fetchState').mockResolvedValue({}); // Mock to resolve a default state
+jest.mock('../../mappers/mappers');
+jest.mock('../../uploader/uploader');
+// jest.mock('../../state/state');
+jest.mock('../../repo/repo');
+jest.mock('node:worker_threads', () => ({
+    parentPort: {
+        postMessage: jest.fn(),
+    },
+}));
+jest.mock('../../attachments-streaming/attachments-streaming-pool', () => {
+    return {
+        AttachmentsStreamingPool: jest.fn().mockImplementation(() => {
+            return {
+                streamAll: jest.fn().mockResolvedValue(undefined),
+            };
+        }),
+    };
+});
+describe(worker_adapter_1.WorkerAdapter.name, () => {
+    let adapter;
+    let mockEvent;
+    let mockAdapterState;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Create mock objects
+        mockEvent = (0, test_helpers_1.createEvent)({ eventType: types_1.EventType.StartExtractingData });
+        const initialState = {
+            attachments: { completed: false },
+            lastSyncStarted: '',
+            lastSuccessfulSyncStarted: '',
+            snapInVersionId: '',
+            toDevRev: {
+                attachmentsMetadata: {
+                    artifactIds: [],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            },
+        };
+        mockAdapterState = new state_1.State({
+            event: mockEvent,
+            initialState: initialState,
+        });
+        // Create the adapter instance
+        adapter = new worker_adapter_1.WorkerAdapter({
+            event: mockEvent,
+            adapterState: mockAdapterState,
+        });
+    });
+    describe(worker_adapter_1.WorkerAdapter.prototype.streamAttachments.name, () => {
+        it('should process all artifact batches successfully', async () => {
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1', 'artifact2'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments from each artifact
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValueOnce({
+                attachments: [
+                    {
+                        url: 'http://example.com/file1.pdf',
+                        id: 'attachment1',
+                        file_name: 'file1.pdf',
+                        parent_id: 'parent1',
+                    },
+                    {
+                        url: 'http://example.com/file2.pdf',
+                        id: 'attachment2',
+                        file_name: 'file2.pdf',
+                        parent_id: 'parent2',
+                    },
+                ],
+            })
+                .mockResolvedValueOnce({
+                attachments: [
+                    {
+                        url: 'http://example.com/file3.pdf',
+                        id: 'attachment3',
+                        file_name: 'file3.pdf',
+                        parent_id: 'parent3',
+                    },
+                ],
+            });
+            // Mock the initializeRepos method
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(adapter.initializeRepos).toHaveBeenCalledWith([
+                { itemType: 'ssor_attachment' },
+            ]);
+            expect(adapter.initializeRepos).toHaveBeenCalledTimes(1);
+            expect(adapter['uploader'].getAttachmentsFromArtifactId).toHaveBeenCalledTimes(2);
+            // Verify state was updated correctly
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
+            expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
+            expect(result).toBeUndefined();
+        });
+        it('[edge] should handle invalid batch size by using 1 instead', async () => {
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                attachments: [
+                    {
+                        url: 'http://example.com/file1.pdf',
+                        id: 'attachment1',
+                        file_name: 'file1.pdf',
+                        parent_id: 'parent1',
+                    },
+                ],
+            });
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+                batchSize: 0,
+            });
+            expect(result).toBeUndefined();
+        });
+        it('[edge] should cap batch size to 50 when batchSize is greater than 50', async () => {
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                attachments: [
+                    {
+                        url: 'http://example.com/file1.pdf',
+                        id: 'attachment1',
+                        file_name: 'file1.pdf',
+                        parent_id: 'parent1',
+                    },
+                ],
+            });
+            // Mock the required methods
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+                batchSize: 100, // Set batch size greater than 50
+            });
+            expect(result).toBeUndefined();
+        });
+        it('[edge] should handle empty attachments metadata artifact IDs', async () => {
+            const mockStream = jest.fn();
+            // Set up adapter state with no artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: [],
+                    lastProcessed: 0,
+                },
+            };
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(result).toBeUndefined();
+        });
+        it('[edge] should handle errors when getting attachments', async () => {
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock error when getting attachments
+            const mockError = new Error('Failed to get attachments');
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                error: mockError,
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(result).toEqual({
+                error: mockError,
+            });
+        });
+        it('[edge] should handle empty attachments array from artifact', async () => {
+            const mockStream = jest.fn();
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting empty attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                attachments: [],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([]);
+            expect(result).toBeUndefined();
+        });
+        it('should use custom processors when provided', async () => {
+            const mockStream = jest.fn();
+            const mockReducer = jest.fn().mockReturnValue(['custom-reduced']);
+            const mockIterator = jest.fn().mockResolvedValue({});
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                attachments: [{ id: 'attachment1' }],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+                processors: {
+                    reducer: mockReducer,
+                    iterator: mockIterator,
+                },
+            });
+            expect(mockReducer).toHaveBeenCalledWith({
+                attachments: [{ id: 'attachment1' }],
+                adapter: adapter,
+                batchSize: 1,
+            });
+            expect(mockIterator).toHaveBeenCalledWith({
+                reducedAttachments: ['custom-reduced'],
+                adapter: adapter,
+                stream: mockStream,
+            });
+            expect(result).toBeUndefined();
+        });
+        it('should handle rate limiting from iterator', async () => {
+            const mockStream = jest.fn();
+            attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
+                return {
+                    // Return an object with a `streamAll` method that resolves to your desired value.
+                    streamAll: jest.fn().mockResolvedValue({ delay: 30 }),
+                };
+            });
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                attachments: [{ id: 'attachment1' }],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(result).toEqual({
+                delay: 30,
+            });
+            // The artifactIds array should remain unchanged
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
+                'artifact1',
+            ]);
+        });
+        it('should handle error from iterator', async () => {
+            const mockStream = jest.fn();
+            attachments_streaming_pool_1.AttachmentsStreamingPool.mockImplementationOnce(() => {
+                return {
+                    // Return an object with a `streamAll` method that resolves to your desired value.
+                    streamAll: jest.fn().mockResolvedValue({
+                        error: 'Mock error',
+                    }),
+                };
+            });
+            // Set up adapter state with artifact IDs
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            // Mock getting attachments
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValue({
+                attachments: [{ id: 'attachment1' }],
+            });
+            // Mock methods
+            adapter.initializeRepos = jest.fn();
+            const result = await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(result).toEqual({
+                error: 'Mock error',
+            });
+            // The artifactIds array should remain unchanged
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toEqual([
+                'artifact1',
+            ]);
+        });
+        it('should reset lastProcessed and attachment IDs list after processing all artifacts', async () => {
+            const mockStream = jest.fn();
+            adapter.state.toDevRev = {
+                attachmentsMetadata: {
+                    artifactIds: ['artifact1'],
+                    lastProcessed: 0,
+                    lastProcessedAttachmentsIdsList: [],
+                },
+            };
+            adapter['uploader'].getAttachmentsFromArtifactId = jest
+                .fn()
+                .mockResolvedValueOnce({
+                attachments: [
+                    {
+                        url: 'http://example.com/file1.pdf',
+                        id: 'attachment1',
+                        file_name: 'file1.pdf',
+                        parent_id: 'parent1',
+                    },
+                    {
+                        url: 'http://example.com/file2.pdf',
+                        id: 'attachment2',
+                        file_name: 'file2.pdf',
+                        parent_id: 'parent2',
+                    },
+                    {
+                        url: 'http://example.com/file3.pdf',
+                        id: 'attachment3',
+                        file_name: 'file3.pdf',
+                        parent_id: 'parent3',
+                    },
+                ],
+            });
+            adapter.processAttachment = jest.fn().mockResolvedValue(null);
+            await adapter.streamAttachments({
+                stream: mockStream,
+            });
+            expect(adapter.state.toDevRev.attachmentsMetadata.artifactIds).toHaveLength(0);
+            expect(adapter.state.toDevRev.attachmentsMetadata.lastProcessed).toBe(0);
+        });
+    });
+    describe(worker_adapter_1.WorkerAdapter.prototype.emit.name, () => {
+        let counter;
+        let mockPostMessage;
+        beforeEach(() => {
+            counter = { counter: 0 };
+            // Import the worker_threads module and spy on parentPort.postMessage
+            const workerThreads = require('node:worker_threads');
+            mockPostMessage = jest.fn().mockImplementation(() => {
+                counter.counter += 1;
+            });
+            // Spy on the parentPort.postMessage method
+            if (workerThreads.parentPort) {
+                jest
+                    .spyOn(workerThreads.parentPort, 'postMessage')
+                    .mockImplementation(mockPostMessage);
+            }
+            else {
+                // If parentPort is null (not in worker context), create a mock
+                workerThreads.parentPort = {
+                    postMessage: mockPostMessage,
+                };
+            }
+        });
+        afterEach(() => {
+            // Restore all mocks
+            jest.restoreAllMocks();
+        });
+        it('should emit only one event when multiple events of same type are sent', async () => {
+            adapter['adapterState'].postState = jest
+                .fn()
+                .mockResolvedValue(undefined);
+            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            expect(counter.counter).toBe(1);
+        });
+        it('should emit event when different event type is sent after previous events', async () => {
+            adapter['adapterState'].postState = jest
+                .fn()
+                .mockResolvedValue(undefined);
+            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            expect(counter.counter).toBe(1);
+        });
+        it('should correctly emit one event even if postState errors', async () => {
+            adapter['adapterState'].postState = jest
+                .fn()
+                .mockRejectedValue(new Error('postState error'));
+            adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            expect(counter.counter).toBe(1);
+        });
+        it('should correctly emit one event even if uploadAllRepos errors', async () => {
+            adapter['adapterState'].postState = jest
+                .fn()
+                .mockResolvedValue(undefined);
+            adapter.uploadAllRepos = jest
+                .fn()
+                .mockRejectedValue(new Error('uploadAllRepos error'));
+            await adapter.emit(types_1.ExtractorEventType.MetadataExtractionError, {
+                reports: [],
+                processed_files: [],
+            });
+            expect(counter.counter).toBe(1);
+        });
+    });
+});

package/dist/multithreading/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/multithreading/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/multithreading/worker.js"],"names":[],"mappings":""}

package/dist/multithreading/worker.js

@@ -0,0 +1,9 @@
+"use strict";
+const { workerData } = require('node:worker_threads');
+require('ts-node').register();
+const { Logger } = require('../logger/logger');
+const { runWithUserLogContext } = require('../logger/logger.context');
+console = new Logger({ event: workerData.event, options: workerData.options });
+runWithUserLogContext(() => {
+    require(workerData.workerPath);
+});

package/dist/repo/repo.d.ts

@@ -0,0 +1,18 @@
+import { Item } from '../repo/repo.interfaces';
+import { ErrorRecord } from '../types/common';
+import { Artifact } from '../uploader/uploader.interfaces';
+import { NormalizedAttachment, NormalizedItem, RepoFactoryInterface } from './repo.interfaces';
+export declare class Repo {
+    readonly itemType: string;
+    private items;
+    private normalize?;
+    private uploader;
+    private onUpload;
+    private options?;
+    uploadedArtifacts: Artifact[];
+    constructor({ event, itemType, normalize, onUpload, options, }: RepoFactoryInterface);
+    getItems(): (NormalizedItem | NormalizedAttachment | Item)[];
+    upload(batch?: (NormalizedItem | NormalizedAttachment | Item)[]): Promise<void | ErrorRecord>;
+    push(items: Item[]): Promise<boolean>;
+}
+//# sourceMappingURL=repo.d.ts.map

package/dist/repo/repo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo.d.ts","sourceRoot":"","sources":["../../src/repo/repo.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,IAAI;IACf,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAmD;IAChE,OAAO,CAAC,SAAS,CAAC,CAAwD;IAC1E,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,OAAO,CAAC,CAAuB;IAChC,iBAAiB,EAAE,QAAQ,EAAE,CAAC;gBAEzB,EACV,KAAK,EACL,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,OAAO,GACR,EAAE,oBAAoB;IAUvB,QAAQ,IAAI,CAAC,cAAc,GAAG,oBAAoB,GAAG,IAAI,CAAC,EAAE;IAItD,MAAM,CACV,KAAK,CAAC,EAAE,CAAC,cAAc,GAAG,oBAAoB,GAAG,IAAI,CAAC,EAAE,GACvD,OAAO,CAAC,IAAI,GAAG,WAAW,CAAC;IAqCxB,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAuC5C"}

package/dist/repo/repo.interfaces.d.ts

@@ -0,0 +1,46 @@
+import { Artifact } from '../uploader/uploader.interfaces';
+import { AirdropEvent } from '../types/extraction';
+import { WorkerAdapterOptions } from '../types/workers';
+/**
+ * RepoInterface is an interface that defines the structure of a repo which is used to store and upload extracted data.
+ */
+export interface RepoInterface {
+    itemType: string;
+    normalize?: (record: object) => NormalizedItem | NormalizedAttachment;
+}
+/**
+ * RepoFactoryInterface is an interface that defines the structure of a repo factory which is used to create a repo.
+ */
+export interface RepoFactoryInterface {
+    event: AirdropEvent;
+    itemType: string;
+    normalize?: (record: object) => NormalizedItem | NormalizedAttachment;
+    onUpload: (artifact: Artifact) => void;
+    options?: WorkerAdapterOptions;
+}
+/**
+ * NormalizedItem is an interface of item after normalization.
+ */
+export interface NormalizedItem {
+    id: string;
+    created_date: string;
+    modified_date: string;
+    data: object;
+}
+/**
+ * NormalizedAttachment is an interface of attachment after normalization.
+ */
+export interface NormalizedAttachment {
+    url: string;
+    id: string;
+    file_name: string;
+    parent_id: string;
+    author_id?: string;
+    inline?: boolean;
+    grand_parent_id?: number | string;
+}
+/**
+ * Item is an interface that defines the structure of an item.
+ */
+export type Item = Record<string, any>;
+//# sourceMappingURL=repo.interfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repo.interfaces.d.ts","sourceRoot":"","sources":["../../src/repo/repo.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,cAAc,GAAG,oBAAoB,CAAC;CACvE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,cAAc,GAAG,oBAAoB,CAAC;IACtE,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IAIjB,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACnC;AAED;;GAEG;AAEH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC"}

package/dist/repo/repo.interfaces.js

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

package/dist/repo/repo.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repo = void 0;
+const constants_1 = require("../common/constants");
+const uploader_1 = require("../uploader/uploader");
+class Repo {
+    constructor({ event, itemType, normalize, onUpload, options, }) {
+        this.items = [];
+        this.itemType = itemType;
+        this.normalize = normalize;
+        this.onUpload = onUpload;
+        this.uploader = new uploader_1.Uploader({ event, options });
+        this.options = options;
+        this.uploadedArtifacts = [];
+    }
+    getItems() {
+        return this.items;
+    }
+    async upload(batch) {
+        const itemsToUpload = batch || this.items;
+        if (itemsToUpload.length > 0) {
+            console.log(`Uploading ${itemsToUpload.length} items of type ${this.itemType}. `);
+            const { artifact, error } = await this.uploader.upload(this.itemType, itemsToUpload);
+            if (error || !artifact) {
+                console.error('Error while uploading batch', error);
+                return error;
+            }
+            this.onUpload(artifact);
+            this.uploadedArtifacts.push(artifact);
+            // Clear the uploaded items from the main items array if no batch was specified
+            if (!batch) {
+                this.items = [];
+            }
+            console.log(`Uploaded ${itemsToUpload.length} items of type ${this.itemType}. Number of items left in repo: ${this.items.length}.`);
+        }
+        else {
+            console.log(`No items to upload for type ${this.itemType}. Skipping upload.`);
+        }
+    }
+    async push(items) {
+        var _a;
+        let recordsToPush;
+        if (!items || items.length === 0) {
+            console.log(`No items to push for type ${this.itemType}. Skipping push.`);
+            return true;
+        }
+        // Normalize items if needed
+        if (this.normalize &&
+            this.itemType != constants_1.AIRDROP_DEFAULT_ITEM_TYPES.EXTERNAL_DOMAIN_METADATA &&
+            this.itemType != constants_1.AIRDROP_DEFAULT_ITEM_TYPES.SSOR_ATTACHMENT) {
+            recordsToPush = items.map((item) => this.normalize(item));
+        }
+        else {
+            recordsToPush = items;
+        }
+        // Add the new records to the items array
+        this.items.push(...recordsToPush);
+        // Upload in batches while the number of items exceeds the batch size
+        const batchSize = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.batchSize) || constants_1.ARTIFACT_BATCH_SIZE;
+        while (this.items.length >= batchSize) {
+            // Slice out a batch of batchSize items to upload
+            const batch = this.items.splice(0, batchSize);
+            try {
+                // Upload the batch
+                await this.upload(batch);
+            }
+            catch (error) {
+                console.error('Error while uploading batch', error);
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.Repo = Repo;

package/dist/repo/repo.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repo.test.d.ts.map

package/dist/repo/repo.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo.test.d.ts","sourceRoot":"","sources":["../../src/repo/repo.test.ts"],"names":[],"mappings":""}