@devrev/airsync-sdk 2.0.0-beta.0

package/dist/uploader/uploader.test.js

@@ -0,0 +1,589 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const form_data_1 = __importDefault(require("form-data"));
+const js_jsonl_1 = require("js-jsonl");
+const zlib_1 = __importDefault(require("zlib"));
+const axios_client_internal_1 = require("../http/axios-client-internal");
+const test_helpers_1 = require("../tests/test-helpers");
+const uploader_helpers_1 = require("./uploader.helpers");
+const uploader_1 = require("./uploader");
+jest.mock('../http/axios-client-internal');
+jest.mock('./uploader.helpers', () => (Object.assign(Object.assign({}, jest.requireActual('./uploader.helpers')), { downloadToLocal: jest.fn(), compressGzip: jest.fn(jest.requireActual('./uploader.helpers').compressGzip) })));
+const mockedAxiosClient = jest.mocked(axios_client_internal_1.axiosClient);
+const mockedDownloadToLocal = jest.mocked(uploader_helpers_1.downloadToLocal);
+const mockedCompressGzip = jest.mocked(uploader_helpers_1.compressGzip);
+describe(uploader_1.Uploader.name, () => {
+    const mockEvent = (0, test_helpers_1.createEvent)();
+    let uploader;
+    beforeEach(() => {
+        uploader = new uploader_1.Uploader({ event: mockEvent });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe(uploader_1.Uploader.prototype.upload.name, () => {
+        const mockArtifactUploadUrlResponse = {
+            data: (0, test_helpers_1.createArtifact)(),
+        };
+        it('should return artifact info when upload flow succeeds', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [
+                { id: 1, name: 'Task 1' },
+                { id: 2, name: 'Task 2' },
+            ];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockResolvedValue((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result).toEqual({
+                artifact: {
+                    id: 'art_123',
+                    item_type: itemType,
+                    item_count: 2,
+                },
+            });
+            expect(result.error).toBeUndefined();
+        });
+        it('should report item_count as 1 when uploading single object', async () => {
+            var _a;
+            // Arrange
+            const itemType = 'metadata';
+            const fetchedObject = { key: 'value' };
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockResolvedValue((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            const result = await uploader.upload(itemType, fetchedObject);
+            // Assert
+            expect((_a = result.artifact) === null || _a === void 0 ? void 0 : _a.item_count).toBe(1);
+            expect(result.error).toBeUndefined();
+        });
+        it('should call downloadToLocal when isLocalDevelopment is true', async () => {
+            // Arrange
+            const localUploader = new uploader_1.Uploader({
+                event: mockEvent,
+                options: { isLocalDevelopment: true },
+            });
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockResolvedValue((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            await localUploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(mockedDownloadToLocal).toHaveBeenCalledWith(itemType, fetchedObjects);
+        });
+        it('should return error when getArtifactUploadUrl fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Get artifact upload URL failed'));
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+        it('should return error when uploadArtifact fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Upload artifact failed'));
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+        it('should return error when confirmArtifactUpload fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedAxiosClient.get.mockResolvedValueOnce(mockArtifactUploadUrlResponse);
+            mockedAxiosClient.post
+                .mockResolvedValueOnce((0, test_helpers_1.createAxiosResponse)())
+                .mockRejectedValueOnce(new Error('Confirm artifact upload failed'));
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+        it('should return error when compression fails', async () => {
+            // Arrange
+            const itemType = 'tasks';
+            const fetchedObjects = [{ id: 1 }];
+            mockedCompressGzip.mockReturnValueOnce({ error: 'Mock error' });
+            // Act
+            const result = await uploader.upload(itemType, fetchedObjects);
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.artifact).toBeUndefined();
+        });
+    });
+    describe(uploader_1.Uploader.prototype.getArtifactUploadUrl.name, () => {
+        it('should return artifact upload info when API call succeeds', async () => {
+            // Arrange
+            const filename = 'test-file.jsonl.gz';
+            const fileType = 'application/x-gzip';
+            const fileSize = 1024;
+            const expectedArtifact = (0, test_helpers_1.createArtifact)();
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: expectedArtifact,
+            });
+            // Act
+            const result = await uploader.getArtifactUploadUrl(filename, fileType, fileSize);
+            // Assert
+            expect(result.response).toEqual(expectedArtifact);
+            expect(mockedAxiosClient.get).toHaveBeenCalledWith(expect.stringContaining('/internal/airdrop.artifacts.upload-url'), expect.objectContaining({
+                params: expect.objectContaining({
+                    file_type: fileType,
+                    file_name: filename,
+                    file_size: fileSize,
+                }),
+            }));
+        });
+        it('should return undefined when API call fails', async () => {
+            // Arrange
+            const filename = 'test-file.jsonl.gz';
+            const fileType = 'application/x-gzip';
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Get artifact upload URL failed'));
+            // Act
+            const result = await uploader.getArtifactUploadUrl(filename, fileType);
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+            expect(mockedAxiosClient.get).toHaveBeenCalled();
+        });
+    });
+    describe(uploader_1.Uploader.prototype.uploadArtifact.name, () => {
+        it('should return response when posting file as multipart form data', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const file = (0, test_helpers_1.createFileBuffer)();
+            const mockResponse = (0, test_helpers_1.createAxiosResponse)();
+            mockedAxiosClient.post.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await uploader.uploadArtifact(artifact, file);
+            // Assert
+            expect(result.response).toBe(mockResponse);
+            expect(mockedAxiosClient.post).toHaveBeenCalledWith(artifact.upload_url, expect.any(form_data_1.default), expect.objectContaining({
+                headers: expect.any(Object),
+            }));
+        });
+        it('should append form_data fields to the multipart form', async () => {
+            // Arrange
+            // form_data is typed as array but implementation iterates with for...in
+            const formDataFields = { key: 'test-key', 'x-amz-credential': 'cred123' };
+            const artifact = {
+                artifact_id: 'art_123',
+                upload_url: 'https://s3.example.com/upload',
+                form_data: formDataFields,
+            };
+            const file = (0, test_helpers_1.createFileBuffer)();
+            const appendSpy = jest.spyOn(form_data_1.default.prototype, 'append');
+            mockedAxiosClient.post.mockResolvedValueOnce({ status: 200 });
+            // Act
+            await uploader.uploadArtifact(artifact, file);
+            // Assert
+            expect(appendSpy).toHaveBeenCalledWith('key', 'test-key');
+            expect(appendSpy).toHaveBeenCalledWith('x-amz-credential', 'cred123');
+            expect(appendSpy).toHaveBeenCalledWith('file', file);
+            appendSpy.mockRestore();
+        });
+        it('should return undefined when upload fails', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const file = (0, test_helpers_1.createFileBuffer)();
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Upload artifact failed'));
+            // Act
+            const result = await uploader.uploadArtifact(artifact, file);
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+        });
+    });
+    describe(uploader_1.Uploader.prototype.confirmArtifactUpload.name, () => {
+        it('should return response when confirming artifact upload', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockResponse = (0, test_helpers_1.createAxiosResponse)();
+            mockedAxiosClient.post.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await uploader.confirmArtifactUpload(artifactId);
+            // Assert
+            expect(result.response).toBe(mockResponse);
+            expect(mockedAxiosClient.post).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                artifact_id: artifactId,
+            }), expect.any(Object));
+        });
+        it('should return undefined when confirmation fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Confirmation failed'));
+            // Act
+            const result = await uploader.confirmArtifactUpload(artifactId);
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+        });
+    });
+    describe(uploader_1.Uploader.prototype.streamArtifact.name, () => {
+        it('should return response when streaming file to upload URL', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const destroyFn = jest.fn();
+            const fileStream = (0, test_helpers_1.createFileStream)({
+                contentLength: 1024,
+                destroyFn,
+            });
+            const mockResponse = (0, test_helpers_1.createAxiosResponse)();
+            mockedAxiosClient.post.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(result.response).toBe(mockResponse);
+            expect(axios_client_internal_1.axiosClient.post).toHaveBeenCalledWith(artifact.upload_url, expect.any(form_data_1.default), expect.objectContaining({
+                headers: expect.any(Object),
+                maxRedirects: 0,
+                validateStatus: expect.any(Function),
+            }));
+            expect(destroyFn).toHaveBeenCalled();
+        });
+        it('should append form_data fields to the multipart form', async () => {
+            // Arrange
+            const formDataFields = { key: 'test-key', 'x-amz-credential': 'cred123' };
+            const artifact = {
+                artifact_id: 'art_123',
+                upload_url: 'https://s3.example.com/upload',
+                form_data: formDataFields,
+            };
+            const fileStream = (0, test_helpers_1.createFileStream)({ contentLength: 1024 });
+            const appendSpy = jest.spyOn(form_data_1.default.prototype, 'append');
+            mockedAxiosClient.post.mockResolvedValueOnce({ status: 200 });
+            // Act
+            await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(appendSpy).toHaveBeenCalledWith('key', 'test-key');
+            expect(appendSpy).toHaveBeenCalledWith('x-amz-credential', 'cred123');
+            appendSpy.mockRestore();
+        });
+        it('should use validateStatus that accepts 2xx and 3xx status codes', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const fileStream = (0, test_helpers_1.createFileStream)({ contentLength: 1024 });
+            mockedAxiosClient.post.mockResolvedValueOnce((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            const callArgs = mockedAxiosClient.post.mock.calls[0];
+            const config = callArgs[2];
+            const validateStatus = config === null || config === void 0 ? void 0 : config.validateStatus;
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(200)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(201)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(299)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(300)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(301)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(399)).toBe(true);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(400)).toBe(false);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(404)).toBe(false);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(500)).toBe(false);
+            expect(validateStatus === null || validateStatus === void 0 ? void 0 : validateStatus(199)).toBe(false);
+        });
+        it('should set Content-Length header when missing from file stream', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const fileStream = (0, test_helpers_1.createFileStream)({ includeContentLength: false });
+            mockedAxiosClient.post.mockResolvedValueOnce((0, test_helpers_1.createAxiosResponse)());
+            // Act
+            await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(mockedAxiosClient.post).toHaveBeenCalledWith(artifact.upload_url, expect.any(form_data_1.default), expect.objectContaining({
+                headers: expect.objectContaining({
+                    'Content-Length': expect.any(Number),
+                }),
+            }));
+        });
+        it('should destroy stream and return undefined when streaming fails', async () => {
+            // Arrange
+            const artifact = (0, test_helpers_1.createArtifact)();
+            const destroyFn = jest.fn();
+            const fileStream = (0, test_helpers_1.createFileStream)({ destroyFn });
+            mockedAxiosClient.post.mockRejectedValueOnce(new Error('Streaming failed'));
+            // Act
+            const result = await uploader.streamArtifact(artifact, fileStream);
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+            expect(destroyFn).toHaveBeenCalled();
+        });
+    });
+    describe('Uploader.destroyStream', () => {
+        it('should call destroy when stream has destroy method', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const destroyFn = jest.fn();
+            const fileStream = {
+                data: { destroy: destroyFn },
+            };
+            // Act
+            destroyStream(fileStream);
+            // Assert
+            expect(destroyFn).toHaveBeenCalled();
+        });
+        it('should call close when stream has close but no destroy method', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const closeFn = jest.fn();
+            const fileStream = {
+                data: { close: closeFn },
+            };
+            // Act
+            destroyStream(fileStream);
+            // Assert
+            expect(closeFn).toHaveBeenCalled();
+        });
+        it('should prefer destroy over close when both are available', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const destroyFn = jest.fn();
+            const closeFn = jest.fn();
+            const fileStream = {
+                data: { destroy: destroyFn, close: closeFn },
+            };
+            // Act
+            destroyStream(fileStream);
+            // Assert
+            expect(destroyFn).toHaveBeenCalled();
+            expect(closeFn).not.toHaveBeenCalled();
+        });
+        it('[edge] should handle stream with no destroy or close methods', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const fileStream = {
+                data: {},
+            };
+            // Act & Assert - should not throw
+            expect(() => destroyStream(fileStream)).not.toThrow();
+        });
+        it('[edge] should handle null/undefined data gracefully', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const fileStreamNullData = {
+                data: null,
+            };
+            const fileStreamUndefinedData = {
+                data: undefined,
+            };
+            // Act & Assert - should not throw
+            expect(() => destroyStream(fileStreamNullData)).not.toThrow();
+            expect(() => destroyStream(fileStreamUndefinedData)).not.toThrow();
+        });
+        it('[edge] should warn when destroy throws an error', () => {
+            // Arrange
+            const destroyStream = (0, test_helpers_1.callPrivateMethod)()(uploader, 'destroyStream');
+            const destroyFn = jest.fn().mockImplementation(() => {
+                throw new Error('Destroy failed');
+            });
+            const fileStream = {
+                data: { destroy: destroyFn },
+            };
+            // Act & Assert - should not throw
+            expect(() => destroyStream(fileStream)).not.toThrow();
+        });
+    });
+    describe('Uploader.getArtifactDownloadUrl', () => {
+        it('should return download URL when API call succeeds', async () => {
+            // Arrange
+            const getArtifactDownloadUrl = (0, test_helpers_1.callPrivateMethod)()(uploader, 'getArtifactDownloadUrl');
+            const artifactId = 'art_123';
+            const expectedDownloadUrl = 'https://s3.example.com/download/art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: { download_url: expectedDownloadUrl },
+            });
+            // Act
+            const result = await getArtifactDownloadUrl(artifactId);
+            // Assert
+            expect(result.response).toBe(expectedDownloadUrl);
+            expect(result.error).toBeUndefined();
+            expect(mockedAxiosClient.get).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                params: expect.objectContaining({
+                    artifact_id: artifactId,
+                }),
+            }));
+        });
+        it('should return undefined when API call fails', async () => {
+            // Arrange
+            const getArtifactDownloadUrl = (0, test_helpers_1.callPrivateMethod)()(uploader, 'getArtifactDownloadUrl');
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('API error'));
+            // Act
+            const result = await getArtifactDownloadUrl(artifactId);
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+        });
+    });
+    describe(uploader_1.Uploader.prototype.getAttachmentsFromArtifactId.name, () => {
+        it('should return attachments when download and parse succeeds', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockAttachments = [
+                { id: '1', url: 'https://example.com/1', file_name: 'file1.txt' },
+                { id: '2', url: 'https://example.com/2', file_name: 'file2.txt' },
+            ];
+            const gzippedData = zlib_1.default.gzipSync(js_jsonl_1.jsonl.stringify(mockAttachments));
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: gzippedData,
+            });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.attachments).toEqual(mockAttachments);
+            expect(result.error).toBeUndefined();
+        });
+        it('should return error when getArtifactDownloadUrl fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            (0, test_helpers_1.spyOnPrivateMethod)(uploader, 'getArtifactDownloadUrl').mockResolvedValueOnce({ error: new Error('API error') });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+        it('should return error when downloadArtifact fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Download error'));
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+        it('should return error when decompression fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: Buffer.from('not valid gzip data'),
+            });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+        it('should return error when JSONL parsing fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const gzippedInvalidJsonl = zlib_1.default.gzipSync('not valid jsonl {{{');
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: gzippedInvalidJsonl,
+            });
+            // Act
+            const result = await uploader.getAttachmentsFromArtifactId({
+                artifact: artifactId,
+            });
+            // Assert
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.attachments).toBeUndefined();
+        });
+    });
+    describe(uploader_1.Uploader.prototype.getJsonObjectByArtifactId.name, () => {
+        it('should return parsed data when downloading non-gzipped artifact', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockData = [
+                { id: 1, name: 'Item 1' },
+                { id: 2, name: 'Item 2' },
+            ];
+            const jsonlData = js_jsonl_1.jsonl.stringify(mockData);
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: Buffer.from(jsonlData),
+            });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({
+                artifactId,
+                isGzipped: false,
+            });
+            // Assert
+            expect(result.response).toEqual(mockData);
+        });
+        it('should return parsed data when downloading gzipped artifact', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            const mockData = [
+                { id: 1, name: 'Item 1' },
+                { id: 2, name: 'Item 2' },
+            ];
+            const gzippedData = zlib_1.default.gzipSync(js_jsonl_1.jsonl.stringify(mockData));
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: gzippedData,
+            });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({
+                artifactId,
+                isGzipped: true,
+            });
+            // Assert
+            expect(result.response).toEqual(mockData);
+        });
+        it('[edge] should return error when getArtifactDownloadUrl fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            (0, test_helpers_1.spyOnPrivateMethod)(uploader, 'getArtifactDownloadUrl').mockResolvedValueOnce({ error: new Error('API error') });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({ artifactId });
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+        });
+        it('[edge] should return error when downloadArtifact fails', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockRejectedValueOnce(new Error('Download error'));
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({ artifactId });
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeInstanceOf(Error);
+        });
+        it('[edge] should return error when decompression fails for gzipped artifact', async () => {
+            // Arrange
+            const artifactId = 'art_123';
+            mockedAxiosClient.get.mockResolvedValueOnce((0, test_helpers_1.createDownloadUrlResponse)());
+            mockedAxiosClient.get.mockResolvedValueOnce({
+                data: Buffer.from('not valid gzip'),
+            });
+            // Act
+            const result = await uploader.getJsonObjectByArtifactId({
+                artifactId,
+                isGzipped: true,
+            });
+            // Assert
+            expect(result.response).toBeUndefined();
+            expect(result.error).toBeDefined();
+        });
+    });
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@devrev/airsync-sdk",
+  "version": "2.0.0-beta.0",
+  "description": "TypeScript SDK for building AirSync snap-ins on the DevRev platform.",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p ./tsconfig.json",
+    "prepare": "npm run build",
+    "start": "ts-node src/index.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint .  --fix",
+    "test": "jest --forceExit --coverage --runInBand --selectProjects default --",
+    "test:backwards-compatibility": "jest --forceExit --runInBand --selectProjects backwards-compatibility --"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devrev/adaas-sdk.git"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com"
+  },
+  "keywords": [],
+  "author": "devrev",
+  "license": "ISC",
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.52.11",
+    "@microsoft/api-extractor-model": "^7.30.7",
+    "@types/express": "^5.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.18.0",
+    "@types/yargs": "^17.0.33",
+    "@typescript-eslint/eslint-plugin": "^8.46.0",
+    "@typescript-eslint/parser": "^8.46.0",
+    "eslint": "9.32.0",
+    "eslint-config-prettier": "^9.1.2",
+    "eslint-plugin-prettier": "4.0.0",
+    "jest": "^29.7.0",
+    "jiti": "^2.6.1",
+    "prettier": "^2.8.3",
+    "ts-jest": "^29.4.4",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.46.1"
+  },
+  "dependencies": {
+    "@devrev/typescript-sdk": "^1.1.59",
+    "axios": "^1.12.1",
+    "axios-retry": "^4.5.0",
+    "express": "^5.2.1",
+    "form-data": "^4.0.4",
+    "js-jsonl": "^1.1.1",
+    "ts-node": "^10.9.2",
+    "yargs": "^17.7.2"
+  },
+  "files": [
+    "dist/**/*",
+    "!dist/tests/**/*"
+  ]
+}