@forge/cache 0.8.0-next.0 → 0.8.0-next.2

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

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

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

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

package/out/__test__/tunnel.test.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tunnel_1 = require("../tunnel");
+const validator_1 = require("../utils/validator");
+const parseSuccessResponse = (response) => {
+    return { response };
+};
+describe('Forge Cache Tunnel', () => {
+    let cache;
+    beforeEach(() => {
+        const __localStore = new Map();
+        cache = new tunnel_1.TunnelCache(__localStore);
+    });
+    test('set method', async () => {
+        const response = await cache.set('key', 'value');
+        expect(response).toStrictEqual(parseSuccessResponse('OK'));
+    });
+    test('get method', async () => {
+        await cache.set('key', 'value');
+        const response = await cache.get('key');
+        expect(response).toStrictEqual(parseSuccessResponse('value'));
+    });
+    test('get method throws error for list value', async () => {
+        cache.__localStore.set('key', ['value1', 'value2']);
+        try {
+            await cache.get('key');
+        }
+        catch (error) {
+            expect(error).toEqual(new validator_1.ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.'));
+        }
+    });
+    test('setIfNotExists method', async () => {
+        const response = await cache.setIfNotExists('key', 'value');
+        expect(response).toStrictEqual(parseSuccessResponse('OK'));
+        const newResponse = await cache.setIfNotExists('key', 'new value');
+        expect(newResponse).toStrictEqual(parseSuccessResponse(null));
+    });
+    test('getAndSet method', async () => {
+        await cache.set('key', 'value');
+        const response = await cache.getAndSet('key', 'new value');
+        expect(response).toStrictEqual(parseSuccessResponse('value'));
+        const newResponse = await cache.get('key');
+        expect(newResponse).toStrictEqual(parseSuccessResponse('new value'));
+    });
+    test('delete method', async () => {
+        await cache.set('key', 'value');
+        const response = await cache.delete('key');
+        expect(response).toStrictEqual(parseSuccessResponse(1));
+        const newResponse = await cache.get('key');
+        expect(newResponse).toStrictEqual(parseSuccessResponse(null));
+    });
+    test('incrementAndGet method', async () => {
+        await cache.set('key', '5');
+        const response = await cache.incrementAndGet('key');
+        expect(response).toStrictEqual(parseSuccessResponse(6));
+    });
+    test('leftPush method', async () => {
+        cache.__localStore.set('key', ['value1', 'value2']);
+        const response = await cache.leftPush('key', 'value3');
+        const result = ['value3', 'value1', 'value2'].length;
+        expect(response).toStrictEqual(parseSuccessResponse(result));
+    });
+    test('rightPop method', async () => {
+        await cache.leftPush('key', 'value1');
+        await cache.leftPush('key', 'value2');
+        const response = await cache.rightPop('key');
+        expect(response).toStrictEqual(parseSuccessResponse('value1'));
+    });
+    test('listLength method', async () => {
+        await cache.leftPush('key', 'value1');
+        await cache.leftPush('key', 'value2');
+        const response = await cache.listLength('key');
+        expect(response).toStrictEqual(parseSuccessResponse(2));
+    });
+    test('decrementAndGet method', async () => {
+        await cache.set('key', '5');
+        const response = await cache.decrementAndGet('key');
+        expect(response).toStrictEqual(parseSuccessResponse(4));
+    });
+    test('incrementAndGet method throws error when key holds a list value', async () => {
+        cache.__localStore.set('key', ['value1', 'value2']);
+        try {
+            await cache.incrementAndGet('key');
+        }
+        catch (error) {
+            expect(error).toEqual(new validator_1.ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.'));
+        }
+    });
+    test('leftPush method throws error when key holds a non-list value', async () => {
+        await cache.set('key', 'value');
+        try {
+            await cache.leftPush('key', 'newValue');
+        }
+        catch (error) {
+            expect(error).toEqual(new validator_1.ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.'));
+        }
+    });
+    test('rightPop method throws error when key holds a non-list value', async () => {
+        await cache.set('key', 'value');
+        try {
+            await cache.rightPop('key');
+        }
+        catch (error) {
+            expect(error).toEqual(new validator_1.ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.'));
+        }
+    });
+    test('listLength method throws error when key holds a non-list value', async () => {
+        await cache.set('key', 'value');
+        try {
+            await cache.listLength('key');
+        }
+        catch (error) {
+            expect(error).toEqual(new validator_1.ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.'));
+        }
+    });
+    test('decrementAndGet method throws error when key holds a list value', async () => {
+        cache.__localStore.set('key', ['value1', 'value2']);
+        try {
+            await cache.decrementAndGet('key');
+        }
+        catch (error) {
+            expect(error).toEqual(new validator_1.ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.'));
+        }
+    });
+    describe('scan method', () => {
+        beforeEach(() => {
+            const __localStore = new Map();
+            cache = new tunnel_1.TunnelCache(__localStore);
+        });
+        test('scan method returns empty array when no matching keys', async () => {
+            cache.__localStore.set('key1', 'value1');
+            cache.__localStore.set('key2', 'value2');
+            cache.__localStore.set('key3', 'value3');
+            cache.__localStore.set('key4', 'value4');
+            cache.__localStore.set('key5', 'value5');
+            const scanResult = await cache.scan('nonexistent*');
+            expect(scanResult.keys).toEqual([]);
+        });
+        test('scan method returns keys starting with "key" prefix', async () => {
+            cache.__localStore.set('key1', 'value1');
+            cache.__localStore.set('key2', 'value2');
+            cache.__localStore.set('otherKey1', 'value3');
+            cache.__localStore.set('otherKey2', 'value4');
+            cache.__localStore.set('key3', 'value5');
+            const scanResult = await cache.scan('key*');
+            expect(scanResult.keys).toEqual(['key1', 'key2', 'key3']);
+        });
+        test('scan method returns keys with "2" in the middle', async () => {
+            cache.__localStore.set('key1', 'value1');
+            cache.__localStore.set('key2', 'value2');
+            cache.__localStore.set('otherKey1', 'value3');
+            cache.__localStore.set('otherKey2', 'value4');
+            cache.__localStore.set('key3', 'value5');
+            const scanResult = await cache.scan('*2*');
+            expect(scanResult.keys).toEqual(['key2', 'otherKey2']);
+        });
+        test('scan method returns keys with "l?st*" redis pattern', async () => {
+            cache.__localStore.set('list1', 'value1');
+            cache.__localStore.set('list2', 'value2');
+            cache.__localStore.set('list3', 'value3');
+            cache.__localStore.set('list4', 'value4');
+            cache.__localStore.set('lest5', 'value5');
+            cache.__localStore.set('key1', 'value1');
+            const scanResult = await cache.scan('l?st*');
+            expect(scanResult.keys).toEqual(['list1', 'list2', 'list3', 'list4', 'lest5']);
+        });
+    });
+});

package/out/cache.d.ts

@@ -1,11 +1,13 @@
 import { RequestInit, Response as nodeFetchResponse } from 'node-fetch';
+import { TunnelCache } from './tunnel';
+import { IForgeCache } from './interfaces/cache';
 export declare type Response = Pick<nodeFetchResponse, 'text' | 'ok' | 'status'>;
 export declare type ScanResult = {
     cursor: string;
     keys: string[];
 };
 export declare function getResponseBody(response: Response): Promise<any>;
-export declare class Cache {
+export declare class Cache implements IForgeCache {
     private client;
     constructor(client: (path: string, options?: RequestInit) => Promise<Response>);
     private buildRequest;
@@ -36,5 +38,5 @@ export declare class Cache {
 }
 export declare function getFetchRmsRuntimeV1(): ((path: string, options?: RequestInit) => Promise<Response>) | undefined;
 export declare function createFetchRmsRuntimeV2(): (path: string, options?: RequestInit) => Promise<Response>;
-export declare function connect(): Cache;
+export declare function connect(): Cache | TunnelCache;
 //# sourceMappingURL=cache.d.ts.map

package/out/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AACA,OAAkB,EAAE,WAAW,EAAE,QAAQ,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAInF,oBAAY,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC;AAEzE,oBAAY,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAGF,wBAAsB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAYtE;AAED,qBAAa,KAAK;IACJ,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;IAGtF,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;IAM5E,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;IAO9F,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAOxC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO3F,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3E,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3E,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOpC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAOrF,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOrD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO7C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAMtD;AAED,wBAAgB,oBAAoB,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAG/G;AAID,wBAAgB,uBAAuB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CA0BpG;AAED,wBAAgB,OAAO,UAItB"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AACA,OAAkB,EAAE,WAAW,EAAE,QAAQ,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAOjD,oBAAY,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC;AAEzE,oBAAY,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAGF,wBAAsB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAYtE;AAED,qBAAa,KAAM,YAAW,WAAW;IAC3B,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;IAGtF,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;IAM5E,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;IAO9F,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAOxC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO3F,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3E,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3E,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOpC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAOrF,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOrD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO7C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAMtD;AAED,wBAAgB,oBAAoB,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAG/G;AAID,wBAAgB,uBAAuB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CA0BpG;AAED,wBAAgB,OAAO,IAAI,KAAK,GAAG,WAAW,CAS7C"}

package/out/cache.js

@@ -5,6 +5,8 @@ const tslib_1 = require("tslib");
 const https_1 = require("https");
 const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const api_1 = require("@forge/api");
+const tunnel_1 = require("./tunnel");
+const __localStore = new Map();
 async function getResponseBody(response) {
     const responseText = await response.text();
     if (!response.ok) {
@@ -107,6 +109,9 @@ function createFetchRmsRuntimeV2() {
 exports.createFetchRmsRuntimeV2 = createFetchRmsRuntimeV2;
 function connect() {
     var _a;
+    if (global.__forge_tunnel__) {
+        return new tunnel_1.TunnelCache(__localStore);
+    }
     const fetch = (_a = getFetchRmsRuntimeV1()) !== null && _a !== void 0 ? _a : createFetchRmsRuntimeV2();
     return new Cache(fetch);
 }

package/out/interfaces/cache.d.ts

@@ -0,0 +1,28 @@
+import { ScanResult } from '../cache';
+export interface IForgeCache {
+    set(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<void>;
+    get(key: string): Promise<string | null>;
+    setIfNotExists(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<'OK' | null>;
+    getAndSet(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<string | null>;
+    delete(key: string): Promise<number>;
+    incrementAndGet(key: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<number>;
+    leftPush(key: string, value: string): Promise<number>;
+    rightPop(key: string): Promise<string | null>;
+    listLength(key: string): Promise<number>;
+    decrementAndGet(key: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<number>;
+    scan(pattern: string, opt?: {
+        cursor?: string;
+        count?: number;
+    }): Promise<ScanResult>;
+}
+//# sourceMappingURL=cache.d.ts.map

package/out/interfaces/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/interfaces/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7E,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,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,CAAC;IAC/F,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC5F,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5E,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5E,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACvF"}

package/out/interfaces/cache.js

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

package/out/tunnel.d.ts

@@ -0,0 +1,33 @@
+import { ScanResult } from './cache';
+import { IForgeCache } from './interfaces/cache';
+export declare type TunnelStoreType = Map<string, string | undefined | string[]>;
+export declare class TunnelCache implements IForgeCache {
+    __localStore: TunnelStoreType;
+    constructor(store: TunnelStoreType);
+    set(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<void>;
+    get(key: string): Promise<string | null>;
+    setIfNotExists(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<'OK' | null>;
+    getAndSet(key: string, value: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<string | null>;
+    delete(key: string): Promise<number>;
+    incrementAndGet(key: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<number>;
+    leftPush(key: string, value: string): Promise<number>;
+    rightPop(key: string): Promise<string | null>;
+    listLength(key: string): Promise<number>;
+    decrementAndGet(key: string, opt?: {
+        ttlSeconds: number;
+    }): Promise<number>;
+    scan(pattern: string, opt?: {
+        cursor?: string;
+        count?: number;
+    }): Promise<ScanResult>;
+    parseSuccessResponse(response: string | number | null | string[]): Promise<any>;
+}
+//# sourceMappingURL=tunnel.d.ts.map

package/out/tunnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel.d.ts","sourceRoot":"","sources":["../src/tunnel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAQjD,oBAAY,eAAe,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAAC,CAAC;AAEzE,qBAAa,WAAY,YAAW,WAAW;IACtC,YAAY,EAAE,eAAe,CAAC;gBACzB,KAAK,EAAE,eAAe;IAKrB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5E,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQxC,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;IAW9F,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAU3F,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASpC,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAS3E,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAcrD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAW7C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWxC,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAW3E,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAsBlG,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;CAKhF"}

package/out/tunnel.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelCache = void 0;
+const validator_1 = require("./utils/validator");
+class TunnelCache {
+    constructor(store) {
+        this.__localStore = store;
+    }
+    async set(key, value, opt) {
+        (0, validator_1.assertIsValidKey)(key);
+        (0, validator_1.assertIsValidValue)(value);
+        (0, validator_1.assertIsSizedValue)(value);
+        this.__localStore.set(key, value);
+        return await this.parseSuccessResponse('OK');
+    }
+    async get(key) {
+        (0, validator_1.assertIsValidKey)(key);
+        const value = this.__localStore.get(key);
+        (0, validator_1.assertAndThrowIfArray)(value);
+        return await this.parseSuccessResponse(value !== null && value !== void 0 ? value : null);
+    }
+    async setIfNotExists(key, value, opt) {
+        (0, validator_1.assertIsValidKey)(key);
+        (0, validator_1.assertIsValidValue)(value);
+        (0, validator_1.assertIsSizedValue)(value);
+        if (this.__localStore.get(key)) {
+            return await this.parseSuccessResponse(null);
+        }
+        this.__localStore.set(key, value);
+        return await this.parseSuccessResponse('OK');
+    }
+    async getAndSet(key, value, opt) {
+        var _a;
+        (0, validator_1.assertIsValidKey)(key);
+        (0, validator_1.assertIsValidValue)(value);
+        (0, validator_1.assertIsSizedValue)(value);
+        const oldValue = (_a = this.__localStore.get(key)) !== null && _a !== void 0 ? _a : null;
+        this.__localStore.set(key, value);
+        return await this.parseSuccessResponse(oldValue);
+    }
+    async delete(key) {
+        (0, validator_1.assertIsValidKey)(key);
+        if (this.__localStore.get(key)) {
+            this.__localStore.delete(key);
+            return await this.parseSuccessResponse(1);
+        }
+        return await this.parseSuccessResponse(0);
+    }
+    async incrementAndGet(key, opt) {
+        var _a;
+        (0, validator_1.assertIsValidKey)(key);
+        const oldValue = this.__localStore.get(key);
+        (0, validator_1.assertAndThrowIfArray)(oldValue);
+        const newValue = Number.parseInt((_a = oldValue) !== null && _a !== void 0 ? _a : '0') + 1;
+        this.__localStore.set(key, newValue.toString());
+        return await this.parseSuccessResponse(newValue);
+    }
+    async leftPush(key, value) {
+        (0, validator_1.assertIsValidKey)(key);
+        (0, validator_1.assertIsValidValue)(value);
+        (0, validator_1.assertIsSizedValue)(value);
+        const oldValue = this.__localStore.get(key);
+        (0, validator_1.assertAndThrowIfNotArray)(oldValue);
+        if (!oldValue) {
+            this.__localStore.set(key, []);
+        }
+        this.__localStore.get(key).unshift(value);
+        return await this.parseSuccessResponse(this.__localStore.get(key).length);
+    }
+    async rightPop(key) {
+        (0, validator_1.assertIsValidKey)(key);
+        const oldValue = this.__localStore.get(key);
+        if (!oldValue) {
+            return await this.parseSuccessResponse(null);
+        }
+        (0, validator_1.assertAndThrowIfNotArray)(oldValue);
+        return await this.parseSuccessResponse(this.__localStore.get(key).pop() || null);
+    }
+    async listLength(key) {
+        (0, validator_1.assertIsValidKey)(key);
+        const oldValue = this.__localStore.get(key);
+        if (!oldValue) {
+            return await this.parseSuccessResponse(0);
+        }
+        (0, validator_1.assertAndThrowIfNotArray)(oldValue);
+        return await this.parseSuccessResponse(this.__localStore.get(key).length);
+    }
+    async decrementAndGet(key, opt) {
+        var _a;
+        (0, validator_1.assertIsValidKey)(key);
+        const oldValue = this.__localStore.get(key);
+        (0, validator_1.assertAndThrowIfArray)(oldValue);
+        const newValue = Number.parseInt((_a = oldValue) !== null && _a !== void 0 ? _a : '0') - 1;
+        this.__localStore.set(key, newValue.toString());
+        return await this.parseSuccessResponse(newValue);
+    }
+    async scan(pattern, opt) {
+        const cursor = (opt === null || opt === void 0 ? void 0 : opt.cursor) ? Number(opt.cursor) : 0;
+        const count = (opt === null || opt === void 0 ? void 0 : opt.count) || 10;
+        const escapedPattern = pattern.replace(/([.+^${}()|\\])/g, '\\$1');
+        const regexPattern = escapedPattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+        const regex = new RegExp(regexPattern);
+        const keys = this.__localStore.keys();
+        const matchedKeys = Array.from(keys).filter((key) => regex.test(key));
+        const resultKeys = matchedKeys.slice(cursor, cursor + count);
+        const nextCursor = cursor + resultKeys.length < matchedKeys.length ? String(cursor + count) : '0';
+        return {
+            cursor: nextCursor,
+            keys: resultKeys
+        };
+    }
+    parseSuccessResponse(response) {
+        return Promise.resolve({
+            response: response !== null && response !== void 0 ? response : null
+        });
+    }
+}
+exports.TunnelCache = TunnelCache;

package/out/utils/__test__/validator.test.d.ts

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

package/out/utils/__test__/validator.test.d.ts.map

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

package/out/utils/__test__/validator.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = require("../validator");
+describe('Forge Cache Tunnel Validators', () => {
+    test('should not throw an error for valid keys', () => {
+        const validKeys = ['key', 'anotherKey', 'KEY', 'key123', '123', 'key-key'];
+        validKeys.forEach((key) => {
+            expect(() => (0, validator_1.assertIsValidKey)(key)).not.toThrow();
+        });
+    });
+    test('should throw an error for invalid keys', () => {
+        const invalidKeys = ['', ' ', null, undefined, {}, [], '@username', 'Hello, World!', 'password&username'];
+        invalidKeys.forEach((key) => {
+            expect(() => (0, validator_1.assertIsValidKey)(key)).toThrow();
+        });
+    });
+    it('should throw an error if value is undefined or null', () => {
+        const invalidKeys = [null, undefined];
+        invalidKeys.forEach((key) => {
+            expect(() => (0, validator_1.assertIsValidValue)(key)).toThrow();
+        });
+    });
+    it('should throw an error if value is not a string', () => {
+        const invalidKeys = [123, {}];
+        invalidKeys.forEach((key) => {
+            expect(() => (0, validator_1.assertIsValidValue)(key)).toThrow();
+        });
+    });
+    it('should not throw an error if value is a non-empty string', () => {
+        expect(() => (0, validator_1.assertIsValidValue)('test')).not.toThrow();
+    });
+    it('should not throw an error if value is within valid range ', () => {
+        expect(() => (0, validator_1.assertIsSizedValue)('this-is-test-value')).not.toThrow();
+    });
+    it('should throw an error if value is too large ', () => {
+        expect(() => (0, validator_1.assertIsSizedValue)('a'.repeat(240 * 1024))).toThrow();
+    });
+});

package/out/utils/validator.d.ts

@@ -0,0 +1,11 @@
+export declare class ForgeCacheTunnelError extends Error {
+    readonly message: string;
+    readonly reason?: any;
+    constructor(message: string, reason?: any);
+}
+export declare function assertIsValidValue(value: unknown): void;
+export declare function assertAndThrowIfArray(value: string | number | undefined | string[]): void;
+export declare function assertAndThrowIfNotArray(value: string | number | undefined | string[]): void;
+export declare function assertIsValidKey(key: unknown): void;
+export declare function assertIsSizedValue(value: unknown): void;
+//# sourceMappingURL=validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/utils/validator.ts"],"names":[],"mappings":"AASA,qBAAa,qBAAsB,SAAQ,KAAK;IAE5C,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,QAAQ,CAAC,MAAM,CAAC;gBADP,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,KAAK;CAIxB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,QAOhD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,QAIlF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,QAIrF;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,QAsB5C;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,QAOhD"}

package/out/utils/validator.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsSizedValue = exports.assertIsValidKey = exports.assertAndThrowIfNotArray = exports.assertAndThrowIfArray = exports.assertIsValidValue = exports.ForgeCacheTunnelError = void 0;
+const tslib_1 = require("tslib");
+const object_sizeof_1 = tslib_1.__importDefault(require("object-sizeof"));
+const MIN_VALID_KEY_LENGTH = 1;
+const MAX_VALID_KEY_LENGTH = 500;
+const VALID_KEY_REGEX = /^(?!\s+$)[a-zA-Z0-9:._\s-#]+$/;
+const KiB = 1024;
+const MAX_VALID_VALUE_LENGTH = 240 * KiB;
+class ForgeCacheTunnelError extends Error {
+    constructor(message, reason) {
+        super(message);
+        this.message = message;
+        this.reason = reason;
+    }
+}
+exports.ForgeCacheTunnelError = ForgeCacheTunnelError;
+function assertIsValidValue(value) {
+    if (value === undefined || value === null) {
+        throw new ForgeCacheTunnelError('Provided value is required');
+    }
+    if (typeof value !== 'string') {
+        throw new ForgeCacheTunnelError('Provided value must be a string', { type: typeof value });
+    }
+}
+exports.assertIsValidValue = assertIsValidValue;
+function assertAndThrowIfArray(value) {
+    if (value && Array.isArray(value)) {
+        throw new ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.');
+    }
+}
+exports.assertAndThrowIfArray = assertAndThrowIfArray;
+function assertAndThrowIfNotArray(value) {
+    if (value && !Array.isArray(value)) {
+        throw new ForgeCacheTunnelError('WRONGTYPE Operation against a key holding the wrong kind of value.');
+    }
+}
+exports.assertAndThrowIfNotArray = assertAndThrowIfNotArray;
+function assertIsValidKey(key) {
+    if (typeof key !== 'string') {
+        throw new Error('Provided key must be a string');
+    }
+    if (key.length < MIN_VALID_KEY_LENGTH) {
+        throw new ForgeCacheTunnelError('Provided key length was under the minimum valid key length', {
+            length: key.length,
+            minLength: MIN_VALID_KEY_LENGTH
+        });
+    }
+    if (key.length > MAX_VALID_KEY_LENGTH) {
+        throw new ForgeCacheTunnelError('Provided key length was above the maximum valid key length', {
+            length: key.length,
+            maxLength: MAX_VALID_KEY_LENGTH
+        });
+    }
+    if (!VALID_KEY_REGEX.test(key)) {
+        throw new ForgeCacheTunnelError('Provided key must match regex', {
+            regex: VALID_KEY_REGEX
+        });
+    }
+}
+exports.assertIsValidKey = assertIsValidKey;
+function assertIsSizedValue(value) {
+    if ((0, object_sizeof_1.default)(value) > MAX_VALID_VALUE_LENGTH) {
+        throw new ForgeCacheTunnelError('Provided value bytes was over maximum valid value size', {
+            bytes: (0, object_sizeof_1.default)(value),
+            maxBytes: MAX_VALID_VALUE_LENGTH
+        });
+    }
+}
+exports.assertIsSizedValue = assertIsSizedValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/cache",
-  "version": "0.8.0-next.0",
+  "version": "0.8.0-next.2",
   "description": "Forge Cache methods",
   "author": "Atlassian",
   "license": "UNLICENSED",
@@ -20,6 +20,7 @@
     "node-fetch": "2.7.0"
   },
   "dependencies": {
-    "@forge/api": "^3.5.0"
+    "@forge/api": "^3.6.0-next.0",
+    "object-sizeof": "^2.6.4"
   }
-}
+}