@forge/os 1.1.0-next.0

package/README.md

@@ -0,0 +1,6 @@
+Library for Forge environment.
+
+Usage example:
+```typescript
+import os from "@forge/os";
+```

package/out/__test__/os.test.d.ts

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

package/out/__test__/os.test.d.ts.map

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

package/out/__test__/os.test.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@forge/api");
+const os_1 = require("../os");
+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 os_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',
+                headers: {
+                    ...DEFAULT_HEADERS
+                }
+            });
+            expect(response).toBe(mockResponse);
+        });
+        it('should handle requests that override the default 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: {
+                    ...DEFAULT_HEADERS,
+                    'Content-Type': 'application/octet-stream'
+                }
+            });
+            expect(response).toBe(mockResponse);
+        });
+    });
+    describe('echo', () => {
+        it('should send a GET request to the echo endpoint', async () => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                text: createMockBody(JSON.stringify({ message: 'Blåhaj' }))
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const response = await osClient.echo();
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/echo', {
+                method: 'GET',
+                redirect: 'follow',
+                headers: {
+                    ...DEFAULT_HEADERS
+                }
+            });
+            expect(mockResponse.status).toBe(200);
+            expect(mockResponse.text).toHaveBeenCalled();
+            expect(response).toEqual({ message: 'Blåhaj' });
+        });
+    });
+    describe('put', () => {
+        it('should send a PUT request with the correct headers and body', async () => {
+            const mockResponse = { ok: true, status: 201, text: createMockBody(null) };
+            mockFetch.mockResolvedValue(mockResponse);
+            const objectId = '1';
+            const buffer = Buffer.from('hello world');
+            await osClient.put(objectId, buffer);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/objects/1', {
+                method: 'PUT',
+                redirect: 'follow',
+                headers: {
+                    ...DEFAULT_HEADERS,
+                    'Content-Type': 'application/octet-stream'
+                },
+                body: buffer
+            });
+            expect(mockResponse.status).toBe(201);
+            expect(mockResponse.text).toHaveBeenCalled();
+        });
+    });
+    describe('get', () => {
+        it('should send a GET request with the correct headers and b', 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/objects/1', {
+                method: 'GET',
+                redirect: 'follow',
+                headers: {
+                    ...DEFAULT_HEADERS
+                }
+            });
+            expect(mockResponse.status).toBe(200);
+            expect(mockResponse.text).toHaveBeenCalled();
+            expect(response).toEqual({ message: 'Blåhaj' });
+        });
+    });
+    describe('delete', () => {
+        it('should send a DELETE request with the correct headers', 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/objects/1', {
+                method: 'DELETE',
+                redirect: 'follow',
+                headers: {
+                    ...DEFAULT_HEADERS
+                }
+            });
+            expect(mockResponse.status).toBe(204);
+            expect(mockResponse.text).toHaveBeenCalled();
+        });
+    });
+    describe('download', () => {
+        it('should send a GET request with the correct headers and return a buffer', async () => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                arrayBuffer: createMockBody(Buffer.from('I shall be downloaded as buffer!'))
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const objectId = '1';
+            const response = await osClient.download(objectId);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/objects/1', {
+                method: 'GET',
+                redirect: 'follow',
+                headers: {
+                    ...DEFAULT_HEADERS,
+                    Accept: 'application/octet-stream'
+                }
+            });
+            expect(mockResponse.status).toBe(200);
+            expect(mockResponse.arrayBuffer).toHaveBeenCalled();
+            expect(response?.toString('utf-8')).toEqual('I shall be downloaded as buffer!');
+        });
+    });
+});

package/out/errorCodes.d.ts

@@ -0,0 +1,5 @@
+export declare const errorCodes: {
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly APP_NOT_ENABLED: "APP_NOT_ENABLED";
+};
+//# 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;;;CAGb,CAAC"}

package/out/errorCodes.js

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

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,6 @@
+import { os } from './os';
+import { errorCodes } from './errorCodes';
+import { ForgeError } from './errors';
+export { errorCodes, os, ForgeError };
+export default os;
+//# 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,EAAE,EAAE,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC;AAEtC,eAAe,EAAE,CAAC"}

package/out/index.js

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

package/out/os.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+export declare class ObjectStoreClient {
+    private sendRequest;
+    private storageApi;
+    echo(): Promise<string | null>;
+    put(objectId: string, buffer: Buffer): Promise<void>;
+    get<DataType>(objectId: string): Promise<DataType | null>;
+    delete(objectId: string): Promise<void>;
+    listVersions(objectId: string): Promise<unknown>;
+    download(objectId: string): Promise<Buffer | null>;
+}
+export declare const os: ObjectStoreClient;
+//# sourceMappingURL=os.d.ts.map

package/out/os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../src/os.ts"],"names":[],"mappings":";AAgBA,qBAAa,iBAAiB;YAEd,WAAW;YAYX,UAAU;IA8BX,IAAI;IAIJ,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpD,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAIzD,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,YAAY,CAAC,QAAQ,EAAE,MAAM;IAI7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAOhE;AAED,eAAO,MAAM,EAAE,mBAA0B,CAAC"}

package/out/os.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.os = 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 || (ValidHttpMethod = {}));
+const DEFAULT_HEADERS = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json'
+};
+class ObjectStoreClient {
+    async sendRequest(path, options) {
+        return await (0, api_1.__fetchProduct)({ provider: 'app', remote: 'os' })(path, {
+            ...options,
+            redirect: 'follow',
+            headers: {
+                ...DEFAULT_HEADERS,
+                ...options?.headers
+            }
+        });
+    }
+    async storageApi(method, path, headers, body) {
+        const response = await this.sendRequest(path, {
+            method,
+            headers,
+            body
+        });
+        await (0, error_handling_1.checkResponseError)(response);
+        if (headers?.Accept === 'application/octet-stream') {
+            return response.arrayBuffer().then((buffer) => Buffer.from(buffer));
+        }
+        const responseText = await response.text();
+        if (responseText) {
+            try {
+                return JSON.parse(responseText);
+            }
+            catch (error) {
+                throw new errors_1.ForgeObjectStoreError(`Unexpected error. Response was not valid JSON: ${responseText}`);
+            }
+        }
+        return null;
+    }
+    async echo() {
+        return this.storageApi(ValidHttpMethod.GET, `api/v1/echo`, { 'Content-Type': 'application/json' });
+    }
+    async put(objectId, buffer) {
+        const headers = {
+            ...DEFAULT_HEADERS,
+            'Content-Type': 'application/octet-stream'
+        };
+        await this.storageApi(ValidHttpMethod.PUT, `api/v1/objects/${objectId}`, headers, buffer);
+    }
+    async get(objectId) {
+        return this.storageApi(ValidHttpMethod.GET, `api/v1/objects/${objectId}`, DEFAULT_HEADERS);
+    }
+    async delete(objectId) {
+        await this.storageApi(ValidHttpMethod.DELETE, `api/v1/objects/${objectId}`, DEFAULT_HEADERS);
+    }
+    async listVersions(objectId) {
+        return this.storageApi(ValidHttpMethod.GET, `api/v1/objects/${objectId}/versions`, DEFAULT_HEADERS);
+    }
+    async download(objectId) {
+        const headers = {
+            ...DEFAULT_HEADERS,
+            Accept: 'application/octet-stream'
+        };
+        return this.storageApi(ValidHttpMethod.GET, `api/v1/objects/${objectId}`, headers);
+    }
+}
+exports.ObjectStoreClient = ObjectStoreClient;
+exports.os = new ObjectStoreClient();

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,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fetch_1 = require("node-fetch");
+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 node_fetch_1.Response('OK', {
+                status: 200,
+                statusText: 'OK'
+            });
+            await expect((0, error_handling_1.checkResponseError)(mockResponse)).resolves.toBeUndefined();
+        });
+        describe('Forge errors - ForgeObjectStoreError', () => {
+            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 node_fetch_1.Response(JSON.stringify({ code, message }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                try {
+                    await (0, error_handling_1.checkResponseError)(mockResponse);
+                    throw new Error('Expected error to be thrown');
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(errors_1.ForgeObjectStoreError);
+                    expect(error).toMatchObject({
+                        responseDetails: {
+                            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 node_fetch_1.Response(JSON.stringify({ code, message, context }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                try {
+                    await (0, error_handling_1.checkResponseError)(mockResponse);
+                    throw new Error('Expected error to be thrown');
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(errors_1.ForgeObjectStoreError);
+                    expect(error).toMatchObject({
+                        code,
+                        message,
+                        context,
+                        responseDetails: {
+                            status: 400,
+                            statusText: 'Bad Request',
+                            traceId
+                        }
+                    });
+                }
+            });
+            it('should include top level additional fields if present in the Forge error', async () => {
+                const extraFields = { extraValue: 'value', debug: true };
+                const mockResponse = new node_fetch_1.Response(JSON.stringify({ code, message, ...extraFields }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                try {
+                    await (0, error_handling_1.checkResponseError)(mockResponse);
+                    throw new Error('Expected error to be thrown');
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(errors_1.ForgeObjectStoreError);
+                    expect(error).toMatchObject({
+                        code,
+                        message,
+                        context: extraFields,
+                        responseDetails: {
+                            status: 400,
+                            statusText: 'Bad Request',
+                            traceId
+                        }
+                    });
+                }
+            });
+            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 node_fetch_1.Response(JSON.stringify({ code, message, context, ...extraFields }), {
+                    status: 400,
+                    statusText: 'Bad Request',
+                    headers: { 'x-trace-id': traceId }
+                });
+                try {
+                    await (0, error_handling_1.checkResponseError)(mockResponse);
+                    throw new Error('Expected error to be thrown');
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(errors_1.ForgeObjectStoreError);
+                    expect(error).toMatchObject({
+                        code,
+                        message,
+                        context: { ...context, ...extraFields },
+                        responseDetails: {
+                            status: 400,
+                            statusText: 'Bad Request',
+                            traceId
+                        }
+                    });
+                }
+            });
+            describe('Handle non forge errors - UNKNOWN_ERROR', () => {
+                it('returns an when no response body', async () => {
+                    const mockResponse = new node_fetch_1.Response(undefined, {
+                        status: 404,
+                        statusText: 'Not Found',
+                        headers: { 'x-trace-id': traceId }
+                    });
+                    try {
+                        await (0, error_handling_1.checkResponseError)(mockResponse);
+                        throw new Error('Expected error to be thrown');
+                    }
+                    catch (error) {
+                        expect(error).toBeInstanceOf(errors_1.ForgeObjectStoreError);
+                        expect(error).toMatchObject({
+                            code: errorCodes_1.errorCodes.UNKNOWN_ERROR,
+                            context: {
+                                responseText: ''
+                            },
+                            responseDetails: {
+                                traceId,
+                                status: 404,
+                                statusText: 'Not Found'
+                            }
+                        });
+                    }
+                });
+                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 node_fetch_1.Response(body, {
+                        status: 500,
+                        statusText: 'Internal Server Error',
+                        headers: { 'x-trace-id': traceId }
+                    });
+                    try {
+                        await (0, error_handling_1.checkResponseError)(mockResponse);
+                        throw new Error('Expected error to be thrown');
+                    }
+                    catch (error) {
+                        expect(error).toBeInstanceOf(errors_1.ForgeObjectStoreError);
+                        expect(error).toMatchObject({
+                            code: errorCodes_1.errorCodes.UNKNOWN_ERROR,
+                            context: {
+                                responseText: body
+                            },
+                            responseDetails: {
+                                traceId,
+                                status: 500,
+                                statusText: 'Internal Server Error'
+                            }
+                        });
+                    }
+                });
+            });
+        });
+    });
+});

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,CAEnE;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB/F"}

package/out/utils/error-handling.js

@@ -0,0 +1,43 @@
+"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');
+}
+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)
+    };
+    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 SQL 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

@@ -0,0 +1,27 @@
+{
+  "name": "@forge/os",
+  "version": "1.1.0-next.0",
+  "description": "Forge Object Store SDK",
+  "author": "Atlassian",
+  "license": "UNLICENSED",
+  "main": "out/index.js",
+  "types": "out/index.d.ts",
+  "files": [
+    "out"
+  ],
+  "scripts": {
+    "build": "yarn run clean && yarn run compile",
+    "clean": "rm -rf ./out && rm -f tsconfig.tsbuildinfo",
+    "compile": "tsc -b -v"
+  },
+  "devDependencies": {
+    "@types/node": "14.18.63",
+    "@types/node-fetch": "^2.6.11",
+    "expect-type": "^0.17.3",
+    "node-fetch": "2.7.0",
+    "jest-when": "^3.6.0"
+  },
+  "dependencies": {
+    "@forge/api": "^4.1.2-next.0"
+  }
+}