@forge/kvs 0.0.2-next.0 → 0.0.2-next.1

package/out/storage-api.d.ts

@@ -0,0 +1,20 @@
+import { FetchMethod } from '@forge/api';
+import { ListResult } from './interfaces/types';
+import { DeleteRequest, EntityDeleteRequest, EntityGetRequest, EntityQueryRequest, EntitySetRequest, GetRequest, QueryRequest, SecretDeleteRequest, SecretGetRequest, SecretSetRequest, SetRequest } from './interfaces/kvs-api';
+export declare class StorageApi {
+    private apiClient;
+    constructor(apiClient: FetchMethod);
+    get<T>(body: GetRequest): Promise<T>;
+    getSecret<T>(body: SecretGetRequest): Promise<T>;
+    getEntity<T>(body: EntityGetRequest): Promise<T>;
+    set<T>(body: SetRequest<T>): Promise<void>;
+    setSecret<T>(body: SecretSetRequest<T>): Promise<void>;
+    setEntity<T>(body: EntitySetRequest<T>): Promise<void>;
+    delete(body: DeleteRequest): Promise<void>;
+    deleteSecret(body: SecretDeleteRequest): Promise<void>;
+    deleteEntity(body: EntityDeleteRequest): Promise<void>;
+    query<T>(body: QueryRequest): Promise<ListResult<T>>;
+    queryEntity<T>(body: EntityQueryRequest): Promise<ListResult<T>>;
+    private request;
+}
+//# sourceMappingURL=storage-api.d.ts.map

package/out/storage-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-api.d.ts","sourceRoot":"","sources":["../src/storage-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,EACL,aAAa,EAEb,mBAAmB,EAEnB,gBAAgB,EAEhB,kBAAkB,EAElB,gBAAgB,EAEhB,UAAU,EAEV,YAAY,EAEZ,mBAAmB,EAEnB,gBAAgB,EAEhB,gBAAgB,EAEhB,UAAU,EAEX,MAAM,sBAAsB,CAAC;AAE9B,qBAAa,UAAU;IACT,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,WAAW;IAEpC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC;IAKpC,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;IAKhD,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;IAKhD,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1C,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAItD,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAItD,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1C,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAItD,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAItD,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAQpD,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAQxD,OAAO;CAyBtB"}

package/out/storage-api.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageApi = void 0;
+const error_handling_1 = require("./utils/error-handling");
+const errors_1 = require("./errors");
+class StorageApi {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async get(body) {
+        const rs = await this.request('/api/v1/get', body, true);
+        return rs.value;
+    }
+    async getSecret(body) {
+        const rs = await this.request('/api/v1/secret/get', body, true);
+        return rs.value;
+    }
+    async getEntity(body) {
+        const rs = await this.request('/api/v1/entity/get', body, true);
+        return rs.value;
+    }
+    async set(body) {
+        await this.request('/api/v1/set', body, false);
+    }
+    async setSecret(body) {
+        await this.request('/api/v1/secret/set', body, false);
+    }
+    async setEntity(body) {
+        await this.request('/api/v1/entity/set', body, false);
+    }
+    async delete(body) {
+        await this.request('/api/v1/delete', body, false);
+    }
+    async deleteSecret(body) {
+        await this.request('/api/v1/secret/delete', body, false);
+    }
+    async deleteEntity(body) {
+        await this.request('/api/v1/entity/delete', body, false);
+    }
+    async query(body) {
+        const rs = await this.request('/api/v1/query', body, true);
+        return {
+            results: rs.data,
+            nextCursor: rs.cursor
+        };
+    }
+    async queryEntity(body) {
+        const rs = await this.request('/api/v1/entity/query', body, true);
+        return {
+            results: rs.data,
+            nextCursor: rs.cursor
+        };
+    }
+    async request(path, body, isResponseExpected) {
+        const requestBody = {
+            method: 'POST',
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json'
+            }
+        };
+        const response = await this.apiClient(path, requestBody);
+        await (0, error_handling_1.checkResponseError)(response);
+        if (!isResponseExpected) {
+            return {};
+        }
+        const responseText = await response.text();
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            throw new errors_1.ForgeKvsError(`Unexpected error. Response was not valid JSON: ${responseText}`);
+        }
+    }
+}
+exports.StorageApi = StorageApi;

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,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const error_handling_1 = require("../error-handling");
+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 - ForgeKvsAPIError', () => {
+            const message = 'A test error has occurred';
+            const code = 'ERROR_CODE';
+            it('should return a ForgeKvsAPIError 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.ForgeKvsAPIError({
+                    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.ForgeKvsAPIError({
+                    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.ForgeKvsAPIError({
+                    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.ForgeKvsAPIError({
+                    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.ForgeKvsAPIError({
+                        status: 404,
+                        statusText: 'Not Found',
+                        traceId
+                    }, {
+                        code: 'UNKNOWN_ERROR',
+                        context: { responseText: '' },
+                        message: 'Unexpected error in Forge KVS API'
+                    }));
+                });
+                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.ForgeKvsAPIError({
+                        status: 500,
+                        statusText: 'Internal Server Error',
+                        traceId
+                    }, {
+                        code: 'UNKNOWN_ERROR',
+                        context: { responseText: body },
+                        message: 'Unexpected error in Forge KVS API'
+                    }));
+                });
+            });
+        });
+    });
+});

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): 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,EAAoB,MAAM,WAAW,CAAC;AAElF,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,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB7E"}

package/out/utils/error-handling.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkResponseError = exports.extractTraceId = exports.safeGetParsedBody = exports.isForgeError = void 0;
+const errors_1 = require("../errors");
+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) {
+    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.ForgeKvsAPIError(details, parsedBody);
+    }
+    throw new errors_1.ForgeKvsAPIError(details, {
+        code: 'UNKNOWN_ERROR',
+        message: 'Unexpected error in Forge KVS API',
+        context: { responseText }
+    });
+}
+exports.checkResponseError = checkResponseError;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@forge/kvs",
-  "version": "0.0.2-next.0",
+  "version": "0.0.2-next.1",
   "description": "Forge Key Value Store SDK",
   "author": "Atlassian",
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE.txt",
   "main": "out/index.js",
   "types": "out/index.d.ts",
   "files": [
@@ -12,8 +12,7 @@
   "scripts": {
     "build": "yarn run clean && yarn run compile",
     "clean": "rm -rf ./out && rm -f tsconfig.tsbuildinfo",
-    "compile": "tsc -b -v",
-    "postbuild": "yarn bolt w forge-scripts preserve-deprecated-tags ../forge-kvs"
+    "compile": "tsc -b -v"
   },
   "devDependencies": {
     "@types/node": "14.18.63"