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

package/dist/state/state.test.js

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../common/constants");
-const test_helpers_1 = require("../tests/test-helpers");
-const extraction_1 = require("../types/extraction");
-const state_1 = require("./state");
-const state_interfaces_1 = require("./state.interfaces");
-/* eslint-disable @typescript-eslint/no-require-imports */
-describe(state_1.State.name, () => {
-    let initSpy;
-    let postStateSpy;
-    let fetchStateSpy;
-    let installInitialDomainMappingSpy;
-    let processExitSpy;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.restoreAllMocks();
-        initSpy = jest.spyOn(state_1.State.prototype, 'init');
-        postStateSpy = jest.spyOn(state_1.State.prototype, 'postState');
-        fetchStateSpy = jest.spyOn(state_1.State.prototype, 'fetchState');
-        installInitialDomainMappingSpy = jest.spyOn(require('../common/install-initial-domain-mapping'), 'installInitialDomainMapping');
-        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
-            throw new Error('process.exit called');
-        });
-    });
-    it.each(constants_1.STATELESS_EVENT_TYPES)('should not init, fetch, post or install IDM for stateless event type %s', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-        });
-        // Act
-        await (0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: {},
-        });
-        // Assert
-        expect(initSpy).not.toHaveBeenCalled();
-        expect(fetchStateSpy).not.toHaveBeenCalled();
-        expect(postStateSpy).not.toHaveBeenCalled();
-        expect(installInitialDomainMappingSpy).not.toHaveBeenCalled();
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching the state fails', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-        });
-        fetchStateSpy.mockRejectedValue({
-            isAxiosError: true,
-            response: { status: 500 },
-        });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
-        // Act & Assert
-        await expect((0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: {},
-        })).rejects.toThrow('process.exit called');
-        expect(processExitSpy).toHaveBeenCalledWith(1);
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if parsing the state fails', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-        });
-        fetchStateSpy.mockResolvedValue('invalid-json');
-        jest.spyOn(console, 'error').mockImplementation(() => { });
-        // Act & Assert
-        await expect((0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: {},
-        })).rejects.toThrow('process.exit called');
-        expect(processExitSpy).toHaveBeenCalledWith(1);
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if fetching is successful but there is no state in the response', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-        });
-        fetchStateSpy.mockResolvedValue(null);
-        jest.spyOn(console, 'error').mockImplementation(() => { });
-        // Act & Assert
-        await expect((0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: {},
-        })).rejects.toThrow('process.exit called');
-        expect(processExitSpy).toHaveBeenCalledWith(1);
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES.filter((eventType) => eventType !== extraction_1.EventType.StartExtractingData))('should call post state with full adapter state if fetching returns 404 for event type %s', async (eventType) => {
-        // Arrange
-        const initialState = {
-            test: 'test',
-        };
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-            contextOverrides: {
-                snap_in_version_id: '',
-            },
-        });
-        fetchStateSpy.mockRejectedValue({
-            isAxiosError: true,
-            response: { status: 404 },
-        });
-        installInitialDomainMappingSpy.mockResolvedValue({
-            success: true,
-        });
-        postStateSpy.mockResolvedValue({
-            success: true,
-        });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        // Act
-        await (0, state_1.createAdapterState)({
-            event,
-            initialState,
-            initialDomainMapping: {},
-        });
-        const expectedState = Object.assign(Object.assign({}, initialState), state_interfaces_1.extractionSdkState);
-        expect(postStateSpy).toHaveBeenCalledWith(expectedState);
-    });
-    it(extraction_1.EventType.StartExtractingData, async () => {
-        // Arrange
-        const initialState = {
-            test: 'test',
-        };
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: extraction_1.EventType.StartExtractingData,
-            contextOverrides: {
-                snap_in_version_id: '',
-            },
-        });
-        fetchStateSpy.mockRejectedValue({
-            isAxiosError: true,
-            response: { status: 404 },
-        });
-        installInitialDomainMappingSpy.mockResolvedValue({
-            success: true,
-        });
-        postStateSpy.mockResolvedValue({
-            success: true,
-        });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        // Act
-        await (0, state_1.createAdapterState)({
-            event,
-            initialState,
-            initialDomainMapping: {},
-        });
-        // Assert
-        // Verify that post state is called with object that contains
-        // lastSyncStarted which is not empty string
-        expect(postStateSpy).toHaveBeenCalledWith(expect.objectContaining({
-            lastSyncStarted: expect.not.stringMatching(/^$/),
-        }));
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should exit the process if initialDomainMapping is not provided for event type %s', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-        });
-        fetchStateSpy.mockResolvedValue(JSON.stringify({
-            test: 'test',
-        }));
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        jest.spyOn(console, 'error').mockImplementation(() => { });
-        // Act & Assert
-        await expect((0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: undefined,
-        })).rejects.toThrow('process.exit called');
-        expect(processExitSpy).toHaveBeenCalledWith(1);
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should not install IDM if version matches for event type %s', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-            contextOverrides: {
-                snap_in_version_id: '1.0.0',
-            },
-        });
-        const stringifiedState = JSON.stringify({
-            test: 'test',
-            snapInVersionId: '1.0.0',
-        });
-        fetchStateSpy.mockResolvedValue(stringifiedState);
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        // Act & Assert
-        await (0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: {},
-        });
-        // Assert
-        expect(installInitialDomainMappingSpy).not.toHaveBeenCalled();
-    });
-    it.each(constants_1.STATEFUL_EVENT_TYPES)('should install IDM if version does not match for event type %s', async (eventType) => {
-        // Arrange
-        const event = (0, test_helpers_1.createEvent)({
-            eventType: eventType,
-            contextOverrides: {
-                snap_in_version_id: '2.0.0',
-            },
-        });
-        const stringifiedState = JSON.stringify({
-            test: 'test',
-            snapInVersionId: '1.0.0',
-        });
-        fetchStateSpy.mockResolvedValue(stringifiedState);
-        installInitialDomainMappingSpy.mockResolvedValue({
-            success: true,
-        });
-        jest.spyOn(console, 'log').mockImplementation(() => { });
-        // Act
-        await (0, state_1.createAdapterState)({
-            event,
-            initialState: {},
-            initialDomainMapping: {},
-        });
-        // Assert
-        expect(installInitialDomainMappingSpy).toHaveBeenCalled();
-    });
-});

package/dist/types/extraction.test.d.ts

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

package/dist/types/extraction.test.d.ts.map

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

package/dist/types/extraction.test.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_helpers_1 = require("../tests/test-helpers");
-const extraction_1 = require("./extraction");
-// Test the EventContext interface and related extraction types
-describe('ExtractionTypes', () => {
-    const baseEvent = (0, test_helpers_1.createEvent)({ eventType: extraction_1.EventType.ExtractionDataStart });
-    it('should create event context without optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        // If this compiles, the test passes
-        expect(event).toBeDefined();
-        expect(event.payload.event_context).toBeDefined();
-    });
-    it('should create event context with all optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z', initial_sync_scope: extraction_1.InitialSyncScope.TIME_SCOPED, reset_extract_from: true });
-        expect(event).toBeDefined();
-        expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
-        expect(event.payload.event_context.initial_sync_scope).toBe(extraction_1.InitialSyncScope.TIME_SCOPED);
-        expect(event.payload.event_context.reset_extract_from).toBe(true);
-    });
-    it('should create event context with partial optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: '2024-01-01T00:00:00Z' });
-        expect(event).toBeDefined();
-        expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
-    });
-    it('should handle different InitialSyncScope values', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { initial_sync_scope: extraction_1.InitialSyncScope.FULL_HISTORY });
-        expect(event.payload.event_context.initial_sync_scope).toBe(extraction_1.InitialSyncScope.FULL_HISTORY);
-    });
-    it('[edge] should handle null event context gracefully', () => {
-        const event = Object.assign({}, baseEvent);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        event.payload.event_context = null;
-        expect(event.payload.event_context).toBeNull();
-    });
-    it('[edge] should handle undefined optional fields', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: undefined, initial_sync_scope: undefined, reset_extract_from: undefined });
-        expect(event.payload.event_context.extract_from).toBeUndefined();
-        expect(event.payload.event_context.initial_sync_scope).toBeUndefined();
-        expect(event.payload.event_context.reset_extract_from).toBeUndefined();
-    });
-    it('[edge] should handle invalid date format in extract_from', () => {
-        const event = Object.assign({}, baseEvent);
-        event.payload.event_context = Object.assign(Object.assign({}, baseEvent.payload.event_context), { extract_from: 'invalid-date-format' });
-        expect(event.payload.event_context.extract_from).toBe('invalid-date-format');
-        // Note: Type validation would typically happen at runtime, not compile time
-    });
-    it('[edge] should handle explicit boolean values for reset_extract_from', () => {
-        const eventWithTrue = (0, test_helpers_1.createEvent)({
-            eventType: extraction_1.EventType.ExtractionDataStart,
-            eventContextOverrides: {
-                reset_extract_from: true,
-            },
-        });
-        const eventWithFalse = (0, test_helpers_1.createEvent)({
-            eventType: extraction_1.EventType.ExtractionDataStart,
-            eventContextOverrides: {
-                reset_extract_from: false,
-            },
-        });
-        expect(eventWithTrue.payload.event_context.reset_extract_from).toBe(true);
-        expect(eventWithFalse.payload.event_context.reset_extract_from).toBe(false);
-        expect(typeof eventWithTrue.payload.event_context.reset_extract_from).toBe('boolean');
-        expect(typeof eventWithFalse.payload.event_context.reset_extract_from).toBe('boolean');
-    });
-});

package/dist/types/index.d.ts

@@ -1,10 +0,0 @@
-export { AdapterUpdateParams, ErrorLevel, ErrorRecord, InitialDomainMapping, LogRecord, SyncMode, } from './common';
-export { AirdropEvent, AirdropMessage, ConnectionData, DomainObjectState, EventContextIn, EventContextOut, EventData, EventType, ExternalProcessAttachmentFunction, ExternalSyncUnit, ExternalSystemAttachmentIteratorFunction, ExternalSystemAttachmentReducerFunction, ExternalSystemAttachmentStreamingFunction, ExternalSystemAttachmentStreamingParams, ExternalSystemAttachmentStreamingResponse, ExtractionMode, ExtractorEvent, ExtractorEventType, ProcessAttachmentReturnType, } from './extraction';
-export { ExternalSystemAttachment, ExternalSystemItem, ExternalSystemItemLoadingParams, ExternalSystemItemLoadingResponse, LoaderEventType, } from './loading';
-export { NormalizedAttachment, NormalizedItem, RepoInterface, } from '../repo/repo.interfaces';
-export { AdapterState } from '../state/state.interfaces';
-export { Artifact, ArtifactsPrepareResponse, SsorAttachment, StreamAttachmentsResponse, StreamResponse, UploadResponse, } from '../uploader/uploader.interfaces';
-export type { MappersCreateParams, MappersGetByExternalIdParams, MappersGetByTargetIdParams, MappersUpdateParams, } from '../mappers/mappers.interface';
-export { SyncMapperRecordStatus, SyncMapperRecordTargetType, } from '../mappers/mappers.interface';
-export type { CollectionData, ConditionalPrivilegeData, CustomLinkData, CustomLinkNames, CustomStage, CustomState, EnumData, EnumValue, EnumValueKey, ExternalDomainMetadata, Field, FieldCondition, FieldConditionComparator, FieldConditionEffect, FieldConditions, FieldKey, FieldPrivilegeData, FieldReferenceData, FieldType, FloatData, IntData, PermissionData, RecordType, RecordTypeCategory, RecordTypeCategoryKey, RecordTypeKey, RecordTypePrivilegeData, RecordTypeScope, ReferenceData, ReferenceDetail, ReferenceType, SchemaVersion, StageKey, StageDiagram, StateKey, StructData, StructTypeKey, StructType, TargetTypeKeyData, TextData, TypedReferenceData, } from './external-domain-metadata';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,WAAW,EACX,oBAAoB,EACpB,SAAS,EACT,QAAQ,GACT,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,YAAY,EACZ,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,SAAS,EACT,SAAS,EACT,iCAAiC,EACjC,gBAAgB,EAChB,wCAAwC,EACxC,uCAAuC,EACvC,yCAAyC,EACzC,uCAAuC,EACvC,yCAAyC,EACzC,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,+BAA+B,EAC/B,iCAAiC,EACjC,eAAe,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,aAAa,GACd,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EACL,QAAQ,EACR,wBAAwB,EACxB,cAAc,EACd,yBAAyB,EACzB,cAAc,EACd,cAAc,GACf,MAAM,iCAAiC,CAAC;AAGzC,YAAY,EACV,mBAAmB,EACnB,4BAA4B,EAC5B,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AAGtC,YAAY,EACV,cAAc,EACd,wBAAwB,EACxB,cAAc,EACd,eAAe,EACf,WAAW,EACX,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,sBAAsB,EACtB,KAAK,EACL,cAAc,EACd,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,EACf,QAAQ,EACR,kBAAkB,EAClB,kBAAkB,EAClB,SAAS,EACT,SAAS,EACT,OAAO,EACP,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,uBAAuB,EACvB,eAAe,EACf,aAAa,EACb,eAAe,EACf,aAAa,EACb,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,kBAAkB,GACnB,MAAM,4BAA4B,CAAC"}

package/dist/types/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncMapperRecordTargetType = exports.SyncMapperRecordStatus = exports.LoaderEventType = exports.ExtractorEventType = exports.ExtractionMode = exports.EventType = exports.SyncMode = exports.ErrorLevel = void 0;
-// Common
-var common_1 = require("./common");
-Object.defineProperty(exports, "ErrorLevel", { enumerable: true, get: function () { return common_1.ErrorLevel; } });
-Object.defineProperty(exports, "SyncMode", { enumerable: true, get: function () { return common_1.SyncMode; } });
-// Extraction
-var extraction_1 = require("./extraction");
-Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return extraction_1.EventType; } });
-Object.defineProperty(exports, "ExtractionMode", { enumerable: true, get: function () { return extraction_1.ExtractionMode; } });
-Object.defineProperty(exports, "ExtractorEventType", { enumerable: true, get: function () { return extraction_1.ExtractorEventType; } });
-// Loading
-var loading_1 = require("./loading");
-Object.defineProperty(exports, "LoaderEventType", { enumerable: true, get: function () { return loading_1.LoaderEventType; } });
-var mappers_interface_1 = require("../mappers/mappers.interface");
-Object.defineProperty(exports, "SyncMapperRecordStatus", { enumerable: true, get: function () { return mappers_interface_1.SyncMapperRecordStatus; } });
-Object.defineProperty(exports, "SyncMapperRecordTargetType", { enumerable: true, get: function () { return mappers_interface_1.SyncMapperRecordTargetType; } });

package/dist/uploader/uploader.helpers.test.d.ts

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

package/dist/uploader/uploader.helpers.test.d.ts.map

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

package/dist/uploader/uploader.helpers.test.js

@@ -1,267 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const fs_2 = require("fs");
-const js_jsonl_1 = require("js-jsonl");
-const zlib_1 = __importDefault(require("zlib"));
-const constants_1 = require("../common/constants");
-const uploader_helpers_1 = require("./uploader.helpers");
-describe('uploader.helpers', () => {
-    let consoleErrorSpy;
-    let consoleLogSpy;
-    let consoleWarnSpy;
-    beforeEach(() => {
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-        consoleErrorSpy.mockRestore();
-        consoleLogSpy.mockRestore();
-        consoleWarnSpy.mockRestore();
-    });
-    describe(uploader_helpers_1.compressGzip.name, () => {
-        it('should compress a string to gzip buffer', () => {
-            // Arrange
-            const input = '{"id":1}\n{"id":2}';
-            // Act
-            const result = (0, uploader_helpers_1.compressGzip)(input);
-            // Assert
-            expect(result.response).toBeInstanceOf(Buffer);
-            const decompressed = zlib_1.default
-                .gunzipSync(result.response)
-                .toString();
-            expect(decompressed).toBe(input);
-        });
-        it('[edge] should return undefined and log error when compression fails', () => {
-            // Arrange
-            const gzipSyncSpy = jest
-                .spyOn(zlib_1.default, 'gzipSync')
-                .mockImplementationOnce(() => {
-                throw new Error('Compression failed');
-            });
-            // Act
-            const result = (0, uploader_helpers_1.compressGzip)('test data');
-            // Assert
-            expect(result.response).toBeUndefined();
-            gzipSyncSpy.mockRestore();
-        });
-    });
-    describe(uploader_helpers_1.decompressGzip.name, () => {
-        it('should decompress a gzip buffer to string', () => {
-            // Arrange
-            const originalString = '{"id":1}\n{"id":2}';
-            const compressed = zlib_1.default.gzipSync(originalString);
-            // Act
-            const result = (0, uploader_helpers_1.decompressGzip)(compressed);
-            // Assert
-            expect(result.response).toBe(originalString);
-        });
-        it('[edge] should return undefined and log error when decompression fails', () => {
-            // Arrange
-            const invalidGzip = Buffer.from('not valid gzip data');
-            // Act
-            const result = (0, uploader_helpers_1.decompressGzip)(invalidGzip);
-            // Assert
-            expect(result.response).toBeUndefined();
-        });
-    });
-    describe(uploader_helpers_1.parseJsonl.name, () => {
-        it('should parse valid JSONL string to array of objects', () => {
-            // Arrange
-            const data = [
-                { id: 1, name: 'Item 1' },
-                { id: 2, name: 'Item 2' },
-            ];
-            const jsonlString = js_jsonl_1.jsonl.stringify(data);
-            // Act
-            const result = (0, uploader_helpers_1.parseJsonl)(jsonlString);
-            // Assert
-            expect(result.response).toEqual(data);
-        });
-        it('[edge] should return null and log error when parsing fails', () => {
-            // Arrange
-            const invalidJsonl = 'not valid jsonl {{{';
-            // Act
-            const result = (0, uploader_helpers_1.parseJsonl)(invalidJsonl);
-            // Assert
-            expect(result.response).toBeUndefined();
-        });
-    });
-    describe(uploader_helpers_1.downloadToLocal.name, () => {
-        const mockExistsSync = jest.spyOn(fs_1.default, 'existsSync');
-        const mockMkdirSync = jest.spyOn(fs_1.default, 'mkdirSync');
-        afterEach(() => {
-            mockExistsSync.mockReset();
-            mockMkdirSync.mockReset();
-        });
-        it('should create extracted_files directory if it does not exist', async () => {
-            // Arrange
-            const itemType = 'tasks';
-            const fetchedObjects = [{ id: 1 }];
-            mockExistsSync.mockReturnValueOnce(false);
-            mockMkdirSync.mockImplementationOnce(() => undefined);
-            const mockFileHandle = {
-                write: jest.fn().mockResolvedValue(undefined),
-                close: jest.fn().mockResolvedValue(undefined),
-            };
-            const fsPromisesOpenSpy = jest
-                .spyOn(fs_2.promises, 'open')
-                .mockResolvedValueOnce(mockFileHandle);
-            // Act
-            await (0, uploader_helpers_1.downloadToLocal)(itemType, fetchedObjects);
-            // Assert
-            expect(mockExistsSync).toHaveBeenCalledWith('extracted_files');
-            expect(mockMkdirSync).toHaveBeenCalledWith('extracted_files');
-            fsPromisesOpenSpy.mockRestore();
-        });
-        it('should write objects as JSONL lines to file', async () => {
-            // Arrange
-            const itemType = 'tasks';
-            const fetchedObjects = [{ id: 1 }, { id: 2 }];
-            mockExistsSync.mockReturnValueOnce(true);
-            const mockFileHandle = {
-                write: jest.fn().mockResolvedValue(undefined),
-                close: jest.fn().mockResolvedValue(undefined),
-            };
-            const fsPromisesOpenSpy = jest
-                .spyOn(fs_2.promises, 'open')
-                .mockResolvedValueOnce(mockFileHandle);
-            // Act
-            await (0, uploader_helpers_1.downloadToLocal)(itemType, fetchedObjects);
-            // Assert
-            expect(mockFileHandle.write).toHaveBeenCalledTimes(2);
-            expect(mockFileHandle.write).toHaveBeenCalledWith('{"id":1}\n');
-            expect(mockFileHandle.write).toHaveBeenCalledWith('{"id":2}\n');
-            expect(mockFileHandle.close).toHaveBeenCalled();
-            fsPromisesOpenSpy.mockRestore();
-        });
-        it('should handle single object (non-array) input', async () => {
-            // Arrange
-            const itemType = 'metadata';
-            const fetchedObject = { key: 'value' };
-            mockExistsSync.mockReturnValueOnce(true);
-            const mockFileHandle = {
-                write: jest.fn().mockResolvedValue(undefined),
-                close: jest.fn().mockResolvedValue(undefined),
-            };
-            const fsPromisesOpenSpy = jest
-                .spyOn(fs_2.promises, 'open')
-                .mockResolvedValueOnce(mockFileHandle);
-            // Act
-            await (0, uploader_helpers_1.downloadToLocal)(itemType, fetchedObject);
-            // Assert
-            expect(mockFileHandle.write).toHaveBeenCalledTimes(1);
-            expect(mockFileHandle.write).toHaveBeenCalledWith('{"key":"value"}\n');
-            fsPromisesOpenSpy.mockRestore();
-        });
-        it('should use .json extension when itemType is external_domain_metadata', async () => {
-            // Arrange
-            const itemType = 'external_domain_metadata';
-            const fetchedObject = { domain: 'example.com' };
-            mockExistsSync.mockReturnValueOnce(true);
-            const mockFileHandle = {
-                write: jest.fn().mockResolvedValue(undefined),
-                close: jest.fn().mockResolvedValue(undefined),
-            };
-            const fsPromisesOpenSpy = jest
-                .spyOn(fs_2.promises, 'open')
-                .mockResolvedValueOnce(mockFileHandle);
-            // Act
-            await (0, uploader_helpers_1.downloadToLocal)(itemType, fetchedObject);
-            // Assert
-            expect(fsPromisesOpenSpy).toHaveBeenCalledWith(expect.stringMatching(/extractor_external_domain_metadata_\d+\.json$/), 'w');
-            fsPromisesOpenSpy.mockRestore();
-        });
-        it('[edge] should reject and log error when file operations fail', async () => {
-            // Arrange
-            const itemType = 'tasks';
-            const fetchedObjects = [{ id: 1 }];
-            const fileError = new Error('File write failed');
-            mockExistsSync.mockReturnValueOnce(true);
-            const fsPromisesOpenSpy = jest
-                .spyOn(fs_2.promises, 'open')
-                .mockRejectedValueOnce(fileError);
-            // Act & Assert
-            await expect((0, uploader_helpers_1.downloadToLocal)(itemType, fetchedObjects)).rejects.toThrow(fileError);
-            fsPromisesOpenSpy.mockRestore();
-        });
-    });
-    describe(uploader_helpers_1.truncateFilename.name, () => {
-        it('should return filename unchanged when within the limit', () => {
-            // Arrange
-            const filename = 'short-filename.txt';
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            expect(result).toBe(filename);
-        });
-        it('should return filename unchanged when exactly at the limit', () => {
-            // Arrange
-            const filename = 'a'.repeat(constants_1.MAX_DEVREV_FILENAME_LENGTH);
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            expect(result).toBe(filename);
-            expect(result.length).toBe(constants_1.MAX_DEVREV_FILENAME_LENGTH);
-        });
-        it('should truncate filename and preserve extension when exceeding the limit', () => {
-            // Arrange
-            const longName = 'a'.repeat(300);
-            const extension = '.txt';
-            const filename = longName + extension;
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            expect(result.length).toBe(constants_1.MAX_DEVREV_FILENAME_LENGTH);
-            expect(result).toContain('...');
-            expect(result.endsWith(extension)).toBe(true);
-        });
-        it('should preserve the last MAX_DEVREV_FILENAME_EXTENSION_LENGTH characters as extension', () => {
-            // Arrange
-            const longName = 'document-'.repeat(50);
-            const extension = '.verylongextension';
-            const filename = longName + extension;
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            expect(result.length).toBe(constants_1.MAX_DEVREV_FILENAME_LENGTH);
-            const expectedExtension = filename.slice(-constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH);
-            expect(result.endsWith(expectedExtension)).toBe(true);
-        });
-        it('should correctly format the truncated filename with ellipsis', () => {
-            // Arrange
-            const filename = 'x'.repeat(300) + '.pdf';
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            const availableNameLength = constants_1.MAX_DEVREV_FILENAME_LENGTH - constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH - 3;
-            const expectedPrefix = 'x'.repeat(availableNameLength);
-            const expectedExtension = filename.slice(-constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH);
-            expect(result).toBe(`${expectedPrefix}...${expectedExtension}`);
-        });
-        it('[edge] should handle filename with no extension', () => {
-            // Arrange
-            const filename = 'a'.repeat(300);
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            expect(result.length).toBe(constants_1.MAX_DEVREV_FILENAME_LENGTH);
-            expect(result).toContain('...');
-            // Last 20 chars are preserved as "extension"
-            expect(result.endsWith('a'.repeat(constants_1.MAX_DEVREV_FILENAME_EXTENSION_LENGTH))).toBe(true);
-        });
-        it('[edge] should handle filename that is just one character over the limit', () => {
-            // Arrange
-            const filename = 'a'.repeat(constants_1.MAX_DEVREV_FILENAME_LENGTH + 1);
-            // Act
-            const result = (0, uploader_helpers_1.truncateFilename)(filename);
-            // Assert
-            expect(result.length).toBe(constants_1.MAX_DEVREV_FILENAME_LENGTH);
-        });
-    });
-});

package/dist/uploader/uploader.test.d.ts

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

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

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