@forge/object-store 1.1.0-next.1 → 1.1.1-next.0

package/out/__test__/object-store.test.d.ts

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

package/out/__test__/object-store.test.d.ts.map

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

package/out/__test__/object-store.test.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@forge/api");
+const object_store_1 = require("../object-store");
+jest.mock('@forge/api');
+const DEFAULT_HEADERS = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json'
+};
+const createMockBody = (body) => {
+    return jest.fn().mockResolvedValue(body);
+};
+describe('ObjectStoreClient', () => {
+    let osClient;
+    let mockFetch;
+    beforeEach(() => {
+        osClient = new object_store_1.ObjectStoreClient();
+        mockFetch = jest.fn();
+        api_1.__fetchProduct.mockReturnValue(mockFetch);
+        jest.clearAllMocks();
+    });
+    describe('sendRequest', () => {
+        it('should send a request with the correct options and return the response', async () => {
+            const mockResponse = { ok: true, status: 200 };
+            mockFetch.mockResolvedValue(mockResponse);
+            const path = 'api/v1/objects/1';
+            const options = { method: 'GET', headers: { ...DEFAULT_HEADERS, 'Custom-Header': 'value' } };
+            const response = await osClient['sendRequest'](path, options);
+            expect(mockFetch).toHaveBeenCalledWith(path, {
+                ...options,
+                redirect: 'follow',
+                headers: {
+                    ...options.headers,
+                    ...DEFAULT_HEADERS
+                }
+            });
+            expect(response).toBe(mockResponse);
+        });
+        it('should handle requests without options', async () => {
+            const mockResponse = { ok: true, status: 200 };
+            mockFetch.mockResolvedValue(mockResponse);
+            const path = 'api/v1/objects/1';
+            const response = await osClient['sendRequest'](path);
+            expect(mockFetch).toHaveBeenCalledWith(path, {
+                redirect: 'follow'
+            });
+            expect(response).toBe(mockResponse);
+        });
+        it('should handle requests that set headers', async () => {
+            const mockResponse = { ok: true, status: 200 };
+            mockFetch.mockResolvedValue(mockResponse);
+            const path = 'api/v1/objects/1';
+            const options = { method: 'GET', headers: { 'Content-Type': 'application/octet-stream' } };
+            const response = await osClient['sendRequest'](path, options);
+            expect(mockFetch).toHaveBeenCalledWith(path, {
+                redirect: 'follow',
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/octet-stream'
+                }
+            });
+            expect(response).toBe(mockResponse);
+        });
+    });
+    describe('get', () => {
+        it('should send a POST request with the correct headers and body', async () => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                text: createMockBody(JSON.stringify({ message: 'Blåhaj' }))
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const objectId = '1';
+            const response = await osClient.get(objectId);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/metadata', {
+                method: 'POST',
+                redirect: 'follow',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    key: objectId
+                })
+            });
+            expect(mockResponse.status).toBe(200);
+            expect(mockResponse.text).toHaveBeenCalled();
+            expect(response).toEqual({ message: 'Blåhaj' });
+        });
+    });
+    describe('delete', () => {
+        it('should send a POST request with the correct headers and body', async () => {
+            const mockResponse = { ok: true, status: 204, text: createMockBody(null) };
+            mockFetch.mockResolvedValue(mockResponse);
+            const objectId = '1';
+            await osClient.delete(objectId);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/delete', {
+                method: 'POST',
+                redirect: 'follow',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ key: objectId })
+            });
+            expect(mockResponse.status).toBe(204);
+            expect(mockResponse.text).toHaveBeenCalled();
+        });
+    });
+    describe('createUploadUrl', () => {
+        it('should send a POST request with the correct headers and body, and return a URL', async () => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                text: createMockBody(JSON.stringify({ url: 'upload-url' }))
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const objectId = '1';
+            const fileProperties = {
+                key: objectId,
+                length: 123,
+                checksum: 'abc123',
+                checksumType: 'SHA1',
+                ttlSeconds: 3600,
+                overwrite: true
+            };
+            const response = await osClient.createUploadUrl(fileProperties);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/upload-url', {
+                method: 'POST',
+                redirect: 'follow',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(fileProperties)
+            });
+            expect(mockResponse.status).toBe(200);
+            expect(mockResponse.text).toHaveBeenCalled();
+            expect(response).toEqual({ url: 'upload-url' });
+        });
+    });
+    describe('createDownloadUrl', () => {
+        it('should send a POST request with the correct headers and body, and return a URL', async () => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                text: createMockBody(JSON.stringify({ url: 'download-url' }))
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const objectId = '1';
+            const response = await osClient.createDownloadUrl(objectId);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/download-url', {
+                method: 'POST',
+                redirect: 'follow',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ key: objectId })
+            });
+            expect(mockResponse.status).toBe(200);
+            expect(mockResponse.text).toHaveBeenCalled();
+            expect(response).toEqual({ url: 'download-url' });
+        });
+    });
+});

package/out/errorCodes.d.ts

@@ -0,0 +1,6 @@
+export declare const errorCodes: {
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly APP_NOT_ENABLED: "APP_NOT_ENABLED";
+    readonly RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED";
+};
+//# sourceMappingURL=errorCodes.d.ts.map

package/out/errorCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorCodes.d.ts","sourceRoot":"","sources":["../src/errorCodes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;CAIb,CAAC"}

package/out/errorCodes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorCodes = void 0;
+exports.errorCodes = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    APP_NOT_ENABLED: 'APP_NOT_ENABLED',
+    RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED'
+};

package/out/errors.d.ts

@@ -0,0 +1,21 @@
+export interface ForgeError {
+    code: string;
+    message: string;
+    context?: Record<string, unknown>;
+}
+export interface APIErrorResponseDetails {
+    status: number;
+    statusText: string;
+    traceId?: string | null;
+}
+export declare class ForgeObjectStoreError extends Error {
+    constructor(message: string);
+}
+export declare class ForgeObjectStoreAPIError extends ForgeObjectStoreError {
+    responseDetails: APIErrorResponseDetails;
+    code: string;
+    message: string;
+    context: Record<string, unknown>;
+    constructor(responseDetails: APIErrorResponseDetails, forgeError: ForgeError);
+}
+//# sourceMappingURL=errors.d.ts.map

package/out/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,wBAAyB,SAAQ,qBAAqB;IACjE,eAAe,EAAE,uBAAuB,CAAC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAErB,eAAe,EAAE,uBAAuB,EAAE,UAAU,EAAE,UAAU;CAU7E"}

package/out/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeObjectStoreAPIError = exports.ForgeObjectStoreError = void 0;
+class ForgeObjectStoreError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ForgeObjectStoreError';
+    }
+}
+exports.ForgeObjectStoreError = ForgeObjectStoreError;
+class ForgeObjectStoreAPIError extends ForgeObjectStoreError {
+    responseDetails;
+    code;
+    message;
+    context;
+    constructor(responseDetails, forgeError) {
+        super(forgeError.message);
+        const { status, statusText, traceId } = responseDetails;
+        this.responseDetails = { status, statusText, traceId };
+        const { code, message, context, ...bodyData } = forgeError;
+        this.code = code;
+        this.message = message;
+        this.context = { ...context, ...bodyData };
+    }
+}
+exports.ForgeObjectStoreAPIError = ForgeObjectStoreAPIError;

package/out/index.d.ts

@@ -0,0 +1,7 @@
+import { objectStore } from './object-store';
+import { errorCodes } from './errorCodes';
+import { ForgeError } from './errors';
+import { ObjectReference } from './types';
+export { errorCodes, objectStore, ForgeError, ObjectReference };
+export default objectStore;
+//# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe,EAAE,CAAC;AAEhE,eAAe,WAAW,CAAC"}

package/out/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectStore = exports.errorCodes = void 0;
+const object_store_1 = require("./object-store");
+Object.defineProperty(exports, "objectStore", { enumerable: true, get: function () { return object_store_1.objectStore; } });
+const errorCodes_1 = require("./errorCodes");
+Object.defineProperty(exports, "errorCodes", { enumerable: true, get: function () { return errorCodes_1.errorCodes; } });
+exports.default = object_store_1.objectStore;

package/out/object-store.d.ts

@@ -0,0 +1,11 @@
+import { ObjectReference, PresignedUrlResponse, UploadUrlBody } from './types';
+export declare class ObjectStoreClient {
+    private sendRequest;
+    private requestJson;
+    get(key: string): Promise<ObjectReference | undefined>;
+    delete(key: string): Promise<void>;
+    createUploadUrl(body: UploadUrlBody): Promise<PresignedUrlResponse | undefined>;
+    createDownloadUrl(key: string): Promise<PresignedUrlResponse | undefined>;
+}
+export declare const objectStore: ObjectStoreClient;
+//# sourceMappingURL=object-store.d.ts.map

package/out/object-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-store.d.ts","sourceRoot":"","sources":["../src/object-store.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAS/E,qBAAa,iBAAiB;YAEd,WAAW;YASX,WAAW;IAmCZ,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAgBtD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAalC,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAgB/E,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;CAWvF;AAED,eAAO,MAAM,WAAW,mBAA0B,CAAC"}

package/out/object-store.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectStore = exports.ObjectStoreClient = void 0;
+const api_1 = require("@forge/api");
+const error_handling_1 = require("./utils/error-handling");
+const errors_1 = require("./errors");
+var ValidHttpMethod;
+(function (ValidHttpMethod) {
+    ValidHttpMethod["PUT"] = "PUT";
+    ValidHttpMethod["GET"] = "GET";
+    ValidHttpMethod["DELETE"] = "DELETE";
+    ValidHttpMethod["POST"] = "POST";
+})(ValidHttpMethod || (ValidHttpMethod = {}));
+class ObjectStoreClient {
+    async sendRequest(path, options) {
+        return await (0, api_1.__fetchProduct)({ provider: 'app', remote: 'os', type: 'os' })(path, {
+            ...options,
+            redirect: 'follow',
+            headers: options?.headers
+        });
+    }
+    async requestJson(method, path, headers, body) {
+        const response = await this.sendRequest(path, {
+            method,
+            headers,
+            body
+        });
+        if (response.status === 404) {
+            return undefined;
+        }
+        await (0, error_handling_1.checkResponseError)(response);
+        const responseText = await response.text();
+        if (!responseText || responseText.trim().length === 0) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            throw new errors_1.ForgeObjectStoreError(`Unexpected error. Response was not valid JSON: ${responseText}`);
+        }
+    }
+    async get(key) {
+        return this.requestJson(ValidHttpMethod.POST, `api/v1/metadata`, {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        }, JSON.stringify({ key }));
+    }
+    async delete(key) {
+        return this.requestJson(ValidHttpMethod.POST, `api/v1/delete`, { Accept: 'application/json', 'Content-Type': 'application/json' }, JSON.stringify({ key }));
+    }
+    async createUploadUrl(body) {
+        return this.requestJson(ValidHttpMethod.POST, 'api/v1/upload-url', {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        }, JSON.stringify(body));
+    }
+    async createDownloadUrl(key) {
+        return this.requestJson(ValidHttpMethod.POST, `api/v1/download-url`, {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        }, JSON.stringify({ key }));
+    }
+}
+exports.ObjectStoreClient = ObjectStoreClient;
+exports.objectStore = new ObjectStoreClient();

package/out/types.d.ts

@@ -0,0 +1,20 @@
+export interface ObjectReference {
+    key: string;
+    checksum: string;
+    size: number;
+    createdAt?: string;
+    currentVersion?: string;
+    contentType?: string;
+}
+export interface UploadUrlBody {
+    key: string;
+    length: number;
+    checksum: string;
+    checksumType: 'SHA1' | 'SHA256' | 'CRC32' | 'CRC32C';
+    ttlSeconds?: number;
+    overwrite?: boolean;
+}
+export interface PresignedUrlResponse {
+    url: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/out/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;CACb"}

package/out/types.js

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

package/out/utils/__test__/error-handling.test.d.ts

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

package/out/utils/__test__/error-handling.test.d.ts.map

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

package/out/utils/__test__/error-handling.test.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errorCodes_1 = require("../../errorCodes");
+const error_handling_1 = require("../error-handling");
+const errors_1 = require("../../errors");
+describe('error-handling', () => {
+    it('isForgeError', () => {
+        expect((0, error_handling_1.isForgeError)({ code: 'code', message: 'message' })).toBe(true);
+        expect((0, error_handling_1.isForgeError)({ code: 'code' })).toBe(false);
+        expect((0, error_handling_1.isForgeError)({ message: 'message' })).toBe(false);
+        expect((0, error_handling_1.isForgeError)({})).toBe(false);
+        expect((0, error_handling_1.isForgeError)(null)).toBe(false);
+        expect((0, error_handling_1.isForgeError)(undefined)).toBe(false);
+        expect((0, error_handling_1.isForgeError)('string')).toBe(false);
+        expect((0, error_handling_1.isForgeError)(123)).toBe(false);
+    });
+    it('safeGetParsedBody', () => {
+        expect((0, error_handling_1.safeGetParsedBody)('{"valid": "json"}')).toEqual({ valid: 'json' });
+        expect((0, error_handling_1.safeGetParsedBody)('invalid json')).toBeUndefined();
+    });
+    describe('checkResponseError', () => {
+        const traceId = 'trace-id';
+        it('should do nothing if response is ok', async () => {
+            const mockResponse = new Response('OK', {
+                status: 200,
+                statusText: 'OK'
+            });
+            await expect((0, error_handling_1.checkResponseError)(mockResponse)).resolves.toBeUndefined();
+        });
+        describe('Forge errors - ForgeObjectStoreAPIError', () => {
+            const message = 'A test error has occurred';
+            const code = 'ERROR_CODE';
+            it('should return a ForgeObjectStoreError when response body is a Forge error', async () => {
+                const mockResponse = new Response(JSON.stringify({ code, message }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toMatchError(new errors_1.ForgeObjectStoreAPIError({
+                    status: 400,
+                    statusText: 'Bad Request',
+                    traceId
+                }, { code, message }));
+            });
+            it('should include context if present in the Forge error', async () => {
+                const context = { key: 'value' };
+                const mockResponse = new Response(JSON.stringify({ code, message, context }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toMatchError(new errors_1.ForgeObjectStoreAPIError({
+                    status: 400,
+                    statusText: 'Bad Request',
+                    traceId
+                }, { code, message, context }));
+            });
+            it('should include top level additional fields if present in the Forge error', async () => {
+                const extraFields = { extraValue: 'value', debug: true };
+                const mockResponse = new Response(JSON.stringify({ code, message, ...extraFields }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toMatchError(new errors_1.ForgeObjectStoreAPIError({
+                    status: 400,
+                    statusText: 'Bad Request',
+                    traceId
+                }, { code, message, context: extraFields }));
+            });
+            it('should merge context and additional top level fields if both present in the Forge error', async () => {
+                const context = { key: 'value' };
+                const extraFields = { extraValue: 'value', debug: true };
+                const mockResponse = new Response(JSON.stringify({ code, message, context, ...extraFields }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toThrowError(new errors_1.ForgeObjectStoreAPIError({
+                    status: 400,
+                    statusText: 'Bad Request',
+                    traceId
+                }, { code, message, context: { ...context, ...extraFields } }));
+            });
+            describe('Handle non forge errors', () => {
+                it('returns an UNKNOWN_ERROR when no response body', async () => {
+                    const mockResponse = new Response(undefined, {
+                        status: 404,
+                        statusText: 'Not Found',
+                        headers: { 'x-trace-id': traceId }
+                    });
+                    await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toMatchError(new errors_1.ForgeObjectStoreAPIError({
+                        status: 404,
+                        statusText: 'Not Found',
+                        traceId
+                    }, {
+                        code: errorCodes_1.errorCodes.UNKNOWN_ERROR,
+                        context: { responseText: '' },
+                        message: 'Unexpected error in Forge OS API request'
+                    }));
+                });
+                it("returns UNKNOWN_ERROR if there is a JSON body that isn't a forge error", async () => {
+                    const body = JSON.stringify({ not: 'a forge error' });
+                    const mockResponse = new Response(body, {
+                        status: 500,
+                        statusText: 'Internal Server Error',
+                        headers: { 'x-trace-id': traceId }
+                    });
+                    await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toMatchError(new errors_1.ForgeObjectStoreAPIError({
+                        status: 500,
+                        statusText: 'Internal Server Error',
+                        traceId
+                    }, {
+                        code: errorCodes_1.errorCodes.UNKNOWN_ERROR,
+                        context: { responseText: body },
+                        message: 'Unexpected error in Forge OS API request'
+                    }));
+                });
+                it('returns RATE_LIMIT_EXCEEDED when status is 429', async () => {
+                    const mockResponse = new Response(undefined, {
+                        status: 429,
+                        statusText: 'Rate Limit Exceeded',
+                        headers: { 'x-trace-id': traceId }
+                    });
+                    await expect(async () => await (0, error_handling_1.checkResponseError)(mockResponse)).rejects.toMatchError(new errors_1.ForgeObjectStoreAPIError({
+                        status: 429,
+                        statusText: 'Rate Limit Exceeded',
+                        traceId
+                    }, {
+                        code: errorCodes_1.errorCodes.RATE_LIMIT_EXCEEDED,
+                        message: 'You have exceeded the rate limits for OS. Please wait and try again later.'
+                    }));
+                });
+            });
+        });
+    });
+});

package/out/utils/error-handling.d.ts

@@ -0,0 +1,7 @@
+import { APIResponse } from '@forge/api';
+import { ForgeError } from '../errors';
+export declare function isForgeError(body: unknown): body is ForgeError;
+export declare function safeGetParsedBody(text: string): unknown | undefined;
+export declare function extractTraceId(response: APIResponse): string | null;
+export declare function checkResponseError(response: APIResponse, message?: string): Promise<void>;
+//# sourceMappingURL=error-handling.d.ts.map

package/out/utils/error-handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handling.d.ts","sourceRoot":"","sources":["../../src/utils/error-handling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAA2B,UAAU,EAA4B,MAAM,WAAW,CAAC;AAG1F,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAE9D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAMnE;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAInE;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+B/F"}

package/out/utils/error-handling.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkResponseError = exports.extractTraceId = exports.safeGetParsedBody = exports.isForgeError = void 0;
+const errors_1 = require("../errors");
+const errorCodes_1 = require("../errorCodes");
+function isForgeError(body) {
+    return typeof body === 'object' && body !== null && 'code' in body && 'message' in body;
+}
+exports.isForgeError = isForgeError;
+function safeGetParsedBody(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+exports.safeGetParsedBody = safeGetParsedBody;
+function extractTraceId(response) {
+    return (response.headers.get('x-b3-traceid') || response.headers.get('x-trace-id') || response.headers.get('atl-traceid'));
+}
+exports.extractTraceId = extractTraceId;
+async function checkResponseError(response, message) {
+    if (response.ok) {
+        return;
+    }
+    const responseText = await response.text();
+    const details = {
+        status: response.status,
+        statusText: response.statusText,
+        traceId: extractTraceId(response)
+    };
+    if (details.status === 429) {
+        throw new errors_1.ForgeObjectStoreAPIError(details, {
+            code: errorCodes_1.errorCodes.RATE_LIMIT_EXCEEDED,
+            message: 'You have exceeded the rate limits for OS. Please wait and try again later.'
+        });
+    }
+    const parsedBody = safeGetParsedBody(responseText);
+    if (parsedBody && isForgeError(parsedBody)) {
+        throw new errors_1.ForgeObjectStoreAPIError(details, parsedBody);
+    }
+    throw new errors_1.ForgeObjectStoreAPIError(details, {
+        code: errorCodes_1.errorCodes.UNKNOWN_ERROR,
+        message: message || 'Unexpected error in Forge OS API request',
+        context: { responseText }
+    });
+}
+exports.checkResponseError = checkResponseError;

package/out/utils/types.d.ts

@@ -0,0 +1,3 @@
+import { APIResponse } from '@forge/api';
+export declare type Response = Pick<APIResponse, 'text' | 'ok' | 'status'>;
+//# sourceMappingURL=types.d.ts.map

package/out/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,oBAAY,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC"}

package/out/utils/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/object-store",
-  "version": "1.1.0-next.1",
+  "version": "1.1.1-next.0",
   "description": "Forge Object Store SDK",
   "author": "Atlassian",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -20,7 +20,7 @@
     "jest-when": "^3.6.0"
   },
   "dependencies": {
-    "@forge/api": "^6.4.0-next.0"
+    "@forge/api": "^6.4.1-next.0"
   },
   "publishConfig": {
     "registry": "https://packages.atlassian.com/api/npm/npm-public/"