@forge/cache 0.1.0-next.0

package/README.md

@@ -0,0 +1,18 @@
+Library for Forge environment.
+
+Usage example:
+```typescript
+import * as cache from "./rockmelon-api";
+
+const cacheClient = cache.connect();
+
+const cacheClient = cache.connect();
+
+await cacheClient.set("hello", "3", { ttlSeconds: 10 });
+
+const result = await cacheClient.setIfNotExists("hello", "3", { ttlSeconds: 10 });
+
+const result = await cacheClient.get("hello");
+
+const result = await cacheClient.incrementAndGet("hello");
+```

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

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

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

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

package/out/__test__/cache.test.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@forge/api");
+const cache_1 = require("../cache");
+describe('createFetch', () => {
+    let fetchMock;
+    let orgFetch;
+    beforeEach(() => {
+        fetchMock = jest.fn();
+        orgFetch = global['fetch'];
+        global['fetch'] = fetchMock;
+    });
+    afterAll(() => {
+        global['fetch'] = orgFetch;
+    });
+    it.each([
+        ['dev.services.atlassian.com', 'rockmelon-storage.dev.atl-paas.net'],
+        ['stg.services.atlassian.com', 'rockmelon-storage.staging.atl-paas.net'],
+        ['services.atlassian.com', 'rockmelon-storage.prod.atl-paas.net']
+    ])('creates a fetch that adds the right headers and url for the %s environment', async (proxyUrl, hostUrl) => {
+        var _a;
+        global['__forge_runtime__'] = {
+            proxy: {
+                token: 'token',
+                url: proxyUrl
+            },
+            rmsStoreUrl: 'url'
+        };
+        const fetch = (0, cache_1.createFetch)();
+        await fetch('/path');
+        const [absoluteUrl, options] = (_a = fetchMock.mock.lastCall) !== null && _a !== void 0 ? _a : ['', {}];
+        expect(absoluteUrl).toEqual('url/path');
+        expect((options === null || options === void 0 ? void 0 : options.agent)['keepAlive']).toBeTruthy();
+        expect(options === null || options === void 0 ? void 0 : options.headers).toMatchObject({
+            Authorization: 'Bearer token',
+            Host: hostUrl
+        });
+    });
+});
+describe('Cache', () => {
+    function buildCache() {
+        const fetch = jest.fn();
+        const cache = new cache_1.Cache({
+            timer: () => ({
+                measure: () => ({
+                    stop: () => {
+                    }
+                })
+            })
+        }, fetch);
+        return { cache, fetch };
+    }
+    describe('set', () => {
+        it('handles success', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({}), status: 200 });
+            await cache.set('key', 'value');
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles success with ttl', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({}), status: 200 });
+            await cache.set('key', 'value', { ttlSeconds: 100 });
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles failure', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
+            await expect(cache.set('key', 'value', { ttlSeconds: 100 })).rejects.toMatchError(new api_1.HttpError('403: Not allowed'));
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+    });
+    describe('setIfNotExists', () => {
+        it('handles success', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 'OK' }), status: 200 });
+            const result = await cache.setIfNotExists('key', 'value');
+            expect(result).toEqual('OK');
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles success when key exists', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: null }), status: 200 });
+            const result = await cache.setIfNotExists('key', 'value');
+            expect(result).toBeNull();
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles success with ttl', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 'OK' }), status: 200 });
+            await cache.setIfNotExists('key', 'value', { ttlSeconds: 100 });
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles failure', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
+            await expect(cache.setIfNotExists('key', 'value', { ttlSeconds: 100 })).rejects.toMatchError(new api_1.HttpError('403: Not allowed'));
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+    });
+    describe('get', () => {
+        it('handles success', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ value: 'asdfasdf' }), status: 200 });
+            const result = await cache.get('key');
+            expect(result).toEqual('asdfasdf');
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles failure', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
+            await expect(cache.get('key')).rejects.toMatchError(new api_1.HttpError('403: Not allowed'));
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+    });
+    describe('incrementAndGet', () => {
+        it('handles success', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 0 }), status: 200 });
+            const result = await cache.incrementAndGet('key');
+            expect(result).toEqual(0);
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles success when key exists', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 11 }), status: 200 });
+            const result = await cache.incrementAndGet('key');
+            expect(result).toEqual(11);
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles success with ttl', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 13 }), status: 200 });
+            await cache.incrementAndGet('key', { ttlSeconds: 100 });
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+        it('handles failure', async () => {
+            const { cache, fetch } = buildCache();
+            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
+            await expect(cache.incrementAndGet('key')).rejects.toMatchError(new api_1.HttpError('403: Not allowed'));
+            expect(fetch.mock.lastCall).toMatchSnapshot();
+        });
+    });
+});

package/out/cache.d.ts

@@ -0,0 +1,23 @@
+import { RequestInit, Response as nodeFetchResponse } from 'node-fetch';
+import { Metrics } from '@forge/metrics';
+export declare type Response = Pick<nodeFetchResponse, 'text' | 'ok' | 'status'>;
+export declare function getResponseBody(response: Response): Promise<any>;
+export declare class Cache {
+    private metrics;
+    private client;
+    constructor(metrics: Metrics, client: (path: string, options?: RequestInit) => Promise<Response>);
+    private buildRequest;
+    set(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<void>;
+    setIfNotExists(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<'OK' | null>;
+    get(key: string): Promise<string>;
+    incrementAndGet(key: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<number>;
+}
+export declare function createFetch(): (path: string, options?: RequestInit) => Promise<Response>;
+export declare function connect(): Cache;
+//# sourceMappingURL=cache.d.ts.map

package/out/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAEA,OAAkB,EAAE,WAAW,EAAE,QAAQ,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnF,OAAO,EAAmB,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG1D,oBAAY,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC;AAGzE,wBAAsB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAYtE;AAED,qBAAa,KAAK;IACJ,OAAO,CAAC,OAAO;IAAW,OAAO,CAAC,MAAM;gBAAhC,OAAO,EAAE,OAAO,EAAU,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;IAEhH,OAAO,CAAC,YAAY;IAUP,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5E,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAS9F,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASjC,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CAQzF;AAcD,wBAAgB,WAAW,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAwBxF;AAGD,wBAAgB,OAAO,UAEtB"}

package/out/cache.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = exports.createFetch = exports.Cache = exports.getResponseBody = void 0;
+const path_1 = require("path");
+const https_1 = require("https");
+const api_1 = require("@forge/api");
+const metrics_1 = require("@forge/metrics");
+async function getResponseBody(response) {
+    const responseText = await response.text();
+    if (!response.ok) {
+        throw new api_1.HttpError(`${response.status}: ${responseText}`);
+    }
+    try {
+        return JSON.parse(responseText);
+    }
+    catch (error) {
+        throw new Error(`Unexpected error. Response text was not a valid JSON: ${responseText}`);
+    }
+}
+exports.getResponseBody = getResponseBody;
+class Cache {
+    constructor(metrics, client) {
+        this.metrics = metrics;
+        this.client = client;
+    }
+    buildRequest(requestBody) {
+        return {
+            method: 'POST',
+            body: JSON.stringify(requestBody),
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        };
+    }
+    async set(key, value, opt) {
+        const timer = this.metrics.timer('cache.set').measure();
+        const response = await this.client('/rms/store/set', this.buildRequest(Object.assign({ key, value }, opt)));
+        timer.stop();
+        await getResponseBody(response);
+    }
+    async setIfNotExists(key, value, opt) {
+        const timer = this.metrics.timer('cache.setIfNotExists').measure();
+        const response = await this.client('/rms/store/setnx', this.buildRequest(Object.assign({ key, value }, opt)));
+        timer.stop();
+        const { response: result } = await getResponseBody(response);
+        return result;
+    }
+    async get(key) {
+        const timer = this.metrics.timer('cache.get').measure();
+        const response = await this.client('/rms/store/get', this.buildRequest({ key }));
+        timer.stop();
+        const { value: result } = await getResponseBody(response);
+        return result;
+    }
+    async incrementAndGet(key, opt) {
+        const timer = this.metrics.timer('cache.incrementAndGet').measure();
+        const response = await this.client('/rms/store/incr', this.buildRequest(Object.assign({ key }, opt)));
+        timer.stop();
+        const { response: result } = await getResponseBody(response);
+        return result;
+    }
+}
+exports.Cache = Cache;
+function determineHost(proxyUrl) {
+    if (proxyUrl.includes('dev.services.atlassian.com')) {
+        return 'rockmelon-storage.dev.atl-paas.net';
+    }
+    else if (proxyUrl.includes('stg.services.atlassian.com')) {
+        return 'rockmelon-storage.staging.atl-paas.net';
+    }
+    return 'rockmelon-storage.prod.atl-paas.net';
+}
+function createFetch() {
+    const { proxy, rmsStoreUrl } = (0, api_1.getRuntime)();
+    const host = determineHost(proxy.url);
+    const agent = new https_1.Agent({ keepAlive: true });
+    if (!rmsStoreUrl) {
+        throw new Error('rms URL not found.');
+    }
+    return async function (path, options) {
+        return await global['fetch']((0, path_1.join)(rmsStoreUrl, path), Object.assign(Object.assign({}, options), { agent, headers: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: `Bearer ${proxy.token}`, Host: host }) }));
+    };
+}
+exports.createFetch = createFetch;
+function connect() {
+    return new Cache(metrics_1.internalMetrics, createFetch());
+}
+exports.connect = connect;

package/out/index.d.ts

@@ -0,0 +1,2 @@
+export { connect } from './cache';
+//# 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,OAAO,EAAE,MAAM,SAAS,CAAC"}

package/out/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = void 0;
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return cache_1.connect; } });

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@forge/cache",
+  "version": "0.1.0-next.0",
+  "description": "Forge Cache methods",
+  "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.44",
+    "@types/node-fetch": "^2.5.7",
+    "node-fetch": "2.6.7"
+  },
+  "dependencies": {
+    "@forge/api": "^2.16.0-next.1",
+    "@forge/metrics": "^0.1.9-next.1"
+  }
+}