@social-mail/social-mail-web-server 1.16.310 → 1.16.312

package/src/common/LocalCache.ts

@@ -1,148 +0,0 @@
-import { globalEnv } from "./globalEnv.js";
-import JsonClient from "./JsonClient.js";
-
-const localCacheJsonClient = new JsonClient(globalEnv.localCache.port);
-
-interface ILocalCacheClient {
-    get(key: string): Promise<any>;
-    delete(key: string): Promise<void>;
-    set(key: string, value: string, ttl, maxAge): Promise<void>;
-    clear();
-}
-
-class LocalCacheClient implements ILocalCacheClient {
-
-    constructor(public readonly bucket: string, public readonly ttlSeconds = 60, public readonly maxAge = 4) {
-    }
-
-    async get(key: string) {
-        const r = await localCacheJsonClient.sendCommand({ cmd: "get", bucket: this.bucket, key });
-        const value = r.value;
-        if(!value) {
-            return void 0;
-        }
-        return value.value;
-    }
-
-    async delete(key: string) {
-        await localCacheJsonClient.sendCommand({ cmd: "delete", bucket: this.bucket, key });
-    }
-
-    async set(key: string, value: string, ttl = this.ttlSeconds, maxAge = this.maxAge) {
-        await localCacheJsonClient.sendCommand({ cmd: "set", bucket: this.bucket, key, value: { value }, ttl, maxAge });
-    }
-
-    clear() {
-        localCacheJsonClient.sendCommand({ cmd: "clear", bucket: this.bucket }).catch(console.error);
-    }
-
-    async getOrCreateAsync<T>(key: string, factory: (k: string) => Promise<T> ): Promise<T> {
-        let r = await this.get(key);
-        if (r === void 0) {
-            r = await factory(key);
-            await this.set(key, r);
-        }
-        return r;
-    }
-
-}
-
-class TestLocalCacheClient implements ILocalCacheClient {
-
-    map = new Map<string, string>();
-
-    constructor(...a: any[]) {
-        // do nothing
-    }
-    async get(key: string): Promise<any> {
-        return this.map.get(key);
-    }
-    async delete(key: string): Promise<void> {
-        this.map.delete(key);
-    }
-    async set(key: string, value: string, ttl: any, maxAge: any) {
-        this.map.set(key, value);
-    }
-
-    clear() {
-        this.map.clear();
-    }
-
-    async getOrCreateAsync<T>(key: string, factory: (k: string) => Promise<T> ): Promise<T> {
-        let r = await this.get(key);
-        if (r === void 0) {
-            r = await factory(key);
-            await this.set(key, r, 0, 0);
-        }
-        return r;
-    }
-
-}
-
-export class ObjectLocalCache<T> implements Disposable {
-
-    private cache: Map<any, ILocalCacheClient> = new Map();
-
-    constructor(private readonly bucketName: string, private readonly ttl?) {
-
-    }
-
-    for(name: keyof T) {
-        let tc = this.cache.get(name);
-        if (!tc) {
-            tc = globalEnv.isLocalTestMode
-                ? new TestLocalCacheClient(`${this.bucketName}.${name as any}`, this.ttl)
-                : new LocalCacheClient(`${this.bucketName}.${name as any}`, this.ttl);
-            this.cache.set(name, tc);
-        }
-        return tc;
-    }
-
-    clear(name?: keyof T) {
-        if (!name) {
-            for (const element of this.cache.values()) {
-                element.clear();
-            }
-            this.cache.clear();
-            return;
-        }
-        this.cache.get(name)?.clear();
-    }
-
-    [Symbol.dispose]() {
-        for (const element of this.cache.values()) {
-            element.clear();
-        }
-    }
-};
-
-export interface ILocalCacheContainer<T> {
-    cache: ObjectLocalCache<T> | undefined;
-}
-
-
-export function localCache<T>() {
-    return function(target:ILocalCacheContainer<T>, key) {
-        const oldMethod = target[key] as (... a: any[]) => any;
-        function value(... a: any[]) {
-            const cache = (this.cache ??= new ObjectLocalCache<T>(`${globalEnv.serverID}:${(target as any).constructor.name}`)).for(key);
-            const cacheKey = a.join();
-            return cache.getOrCreateAsync(cacheKey, (k) => {
-                const nv = oldMethod.apply(this, a);
-                nv?.catch((error) => {
-                    console.error(`${key}(${cacheKey}) failed with`);
-                    console.error(error);
-                    cache.delete(cacheKey);
-                });
-                return nv;
-            });
-        }
-        const d = {
-            value,
-            enumerable: true,
-            configurable: true
-        };
-        Object.defineProperty(target, key, d);
-        return d;
-    } as any;
-}