gingersnap 0.22.0

package/data/store/manager.cjs

@@ -0,0 +1,206 @@
+'use strict';
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var WatchableObject = require('../../data-structures/object/WatchableObject.cjs');
+require('object-hash');
+require('ramda');
+var stream = require('../../stream.cjs');
+var future = require('../../future/future.cjs');
+require('uuid');
+var Pair = require('../../data-structures/array/Pair.cjs');
+var model = require('../model/model.cjs');
+var property = require('../model/property.cjs');
+var types = require('../model/types.cjs');
+require('../model/credentials.cjs');
+
+class PersistedCachedRecord extends model.Model {
+    setValue(v) {
+        this.value = v;
+    }
+}
+_tslib.__decorate([
+    property.Field("lastModifiedOn"),
+    _tslib.__metadata("design:type", Number)
+], PersistedCachedRecord.prototype, "lastModifiedOn", void 0);
+_tslib.__decorate([
+    property.Field("value"),
+    _tslib.__metadata("design:type", Function),
+    _tslib.__metadata("design:paramtypes", [Object]),
+    _tslib.__metadata("design:returntype", void 0)
+], PersistedCachedRecord.prototype, "setValue", null);
+class Cache {
+    constructor(decode, encode, persistStore, maxSize, expiryPeriod) {
+        this.decode = decode;
+        this.encode = encode;
+        this.persistStore = persistStore;
+        this.expiryPeriod = expiryPeriod;
+        this.memStore = new WatchableObject.WatchableObject(maxSize, expiryPeriod);
+        if (persistStore) {
+            this.memStore.onDelete((k) => {
+                persistStore.remove(this.getTransformedKey(k)).schedule();
+            });
+            this.memStore.onSet((k, v) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                const record = new PersistedCachedRecord();
+                const result = this.encode(v);
+                if (result instanceof Promise || result instanceof future.Future) {
+                    record.value = yield result;
+                }
+                else {
+                    record.value = result;
+                }
+                record.lastModifiedOn = Date.now();
+                persistStore.set(this.getTransformedKey(k), record.json()).schedule();
+            }));
+            this.memStore.onClear(() => {
+                persistStore.clear().schedule();
+            });
+        }
+    }
+    get(key) {
+        return future.Future.of((resolve, reject, signal) => {
+            const value = this.memStore.get(key);
+            if (value === undefined && this.persistStore) {
+                const transformedKey = this.getTransformedKey(key);
+                resolve(this.persistStore
+                    .get(transformedKey)
+                    .thenApply(({ value }) => {
+                    if (value) {
+                        const val = PersistedCachedRecord.fromString(value, types.DataFormat.JSON);
+                        val.value = this.decode(val.value);
+                        return val;
+                    }
+                })
+                    .thenApply(({ value, signal }) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    if (value) {
+                        if (this.expiryPeriod) {
+                            const remainingTime = Date.now() - value.lastModifiedOn - future.calculatePeriodValue(this.expiryPeriod);
+                            if (remainingTime <= 0) {
+                                yield this.persistStore.remove(transformedKey).registerSignal(signal);
+                                return;
+                            }
+                            this.memStore.set(key, value.value, { milliseconds: remainingTime });
+                        }
+                        else {
+                            this.memStore.set(key, value.value);
+                        }
+                    }
+                    return value === null || value === void 0 ? void 0 : value.value;
+                }))
+                    .registerSignal(signal));
+            }
+            resolve(value);
+        });
+    }
+    getSync(key) {
+        return this.memStore.get(key);
+    }
+    set(key, value) {
+        this.memStore.set(key, value);
+    }
+    remove(key) {
+        this.memStore.delete(key);
+    }
+    keys() {
+        var _a, _b;
+        return ((_b = (_a = this.persistStore) === null || _a === void 0 ? void 0 : _a.keys().map(this.getInversedKey)) !== null && _b !== void 0 ? _b : stream.Stream.of(this.memStore.keys()));
+    }
+    keysSync() {
+        return this.memStore.keys();
+    }
+    values() {
+        var _a, _b;
+        return ((_b = (_a = this.persistStore) === null || _a === void 0 ? void 0 : _a.values().map((v) => PersistedCachedRecord.fromString(v, types.DataFormat.JSON)).map((v) => v.value)) !== null && _b !== void 0 ? _b : stream.Stream.of(this.valuesSync()));
+    }
+    valuesSync() {
+        return this.memStore.values(true);
+    }
+    clear() {
+        this.memStore.clear();
+    }
+    [Symbol.asyncIterator]() {
+        const stream = this.keys()
+            .map((k) => this.get(k).thenApply(({ value }) => Pair.pair(k, value)))
+            .filter((v) => v.second !== undefined);
+        return stream[Symbol.asyncIterator]();
+    }
+    getTransformedKey(key) {
+        let transformedKey;
+        switch (typeof key) {
+            case "string":
+                transformedKey = "<string>" + key;
+                break;
+            case "number":
+                transformedKey = `<number>${key}`;
+                break;
+            case "boolean":
+                transformedKey = `<boolean>${key}`;
+                break;
+            case "object":
+                if (key instanceof Date) {
+                    transformedKey = "<iso>" + key.toISOString();
+                    break;
+                }
+                else if (Array.isArray(key)) {
+                    transformedKey = "<json>" + JSON.stringify(key);
+                    break;
+                }
+            default:
+                throw new Error("invalid key");
+        }
+        return transformedKey;
+    }
+    getInversedKey(transformedKey) {
+        let key;
+        const rawKey = transformedKey.substring(8);
+        switch (transformedKey.substring(0, 8)) {
+            case "<string>":
+                key = rawKey;
+                break;
+            case "<number>":
+                key = Number(rawKey);
+                break;
+            case "<bool  >":
+                key = (rawKey === "true");
+                break;
+            case "<date  >":
+                key = new Date(rawKey);
+                break;
+            case "<json  >":
+                key = JSON.parse(rawKey);
+                break;
+            default:
+                throw new Error("invalid key");
+        }
+        return key;
+    }
+}
+class CacheManager {
+    constructor(persistStore, maxSize, expiryPeriod) {
+        this.persistStore = persistStore;
+        this.maxSize = maxSize;
+        this.expiryPeriod = expiryPeriod;
+        this.memStores = new Map();
+    }
+    createCache(name, persist, encoder, decoder, maxSize, expiryPeriod) {
+        if (persist && (!encoder || !decoder)) {
+            throw new Error("encoder and decoder required for persisting data");
+        }
+        if (persist && !this.persistStore) {
+            throw new Error("store required for persisting data");
+        }
+        const cache = new Cache(decoder, encoder, persist ? this.persistStore : undefined, maxSize !== null && maxSize !== void 0 ? maxSize : this.maxSize, expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod);
+        this.memStores.set(name, cache);
+        return cache;
+    }
+    getCache(name) {
+        return this.memStores.get(name);
+    }
+    removeCache(name) {
+        const cache = this.memStores.get(name);
+        this.memStores.delete(name);
+        cache === null || cache === void 0 ? void 0 : cache.clear();
+    }
+}
+
+exports.Cache = Cache;
+exports.CacheManager = CacheManager;

package/data/store/manager.d.ts

@@ -0,0 +1,44 @@
+import { Future, WaitPeriod } from "../../future";
+import { Pair } from "../../data-structures/array";
+import { Stream } from "../../stream";
+export interface PersistenceStore {
+    open: () => Future<void>;
+    close: () => Future<void>;
+    get: (key: string) => Future<string | undefined>;
+    set: (key: string, value: string) => Future<void>;
+    remove: (key: string) => Future<void>;
+    keys: () => Stream<string>;
+    values: () => Stream<string>;
+    length: () => Future<number>;
+    clear: () => Future<void>;
+}
+export declare class Cache<T, K> implements AsyncIterable<Pair<T, K>> {
+    private readonly decode;
+    private readonly encode;
+    private readonly persistStore?;
+    private readonly expiryPeriod?;
+    constructor(decode: (v: string) => K, encode: (v: K) => string | Future<string> | Promise<string>, persistStore?: PersistenceStore, maxSize?: number, expiryPeriod?: WaitPeriod);
+    private readonly memStore;
+    get(key: T): Future<K | undefined>;
+    getSync(key: T): K;
+    set(key: T, value: K): void;
+    remove(key: T): void;
+    keys(): Stream<T>;
+    keysSync(): IterableIterator<T>;
+    values(): Stream<K>;
+    valuesSync(): K[];
+    clear(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<Pair<T, K>, any, unknown>;
+    private getTransformedKey;
+    private getInversedKey;
+}
+export declare class CacheManager {
+    private readonly persistStore?;
+    private readonly maxSize?;
+    private readonly expiryPeriod?;
+    private readonly memStores;
+    constructor(persistStore?: PersistenceStore, maxSize?: number, expiryPeriod?: WaitPeriod);
+    createCache<T, K>(name: string, persist: boolean, encoder?: (v: K) => string | Future<string> | Promise<string>, decoder?: (v: string) => K, maxSize?: number, expiryPeriod?: WaitPeriod): Cache<T, K>;
+    getCache<T, K>(name: string): Cache<T, K>;
+    removeCache(name: string): void;
+}

package/data/store/manager.mjs

@@ -0,0 +1,203 @@
+import { __decorate, __metadata, __awaiter } from '../../_virtual/_tslib.mjs';
+import { WatchableObject } from '../../data-structures/object/WatchableObject.mjs';
+import 'object-hash';
+import 'ramda';
+import { Stream } from '../../stream.mjs';
+import { Future, calculatePeriodValue } from '../../future/future.mjs';
+import 'uuid';
+import { pair } from '../../data-structures/array/Pair.mjs';
+import { Model } from '../model/model.mjs';
+import { Field } from '../model/property.mjs';
+import { DataFormat } from '../model/types.mjs';
+import '../model/credentials.mjs';
+
+class PersistedCachedRecord extends Model {
+    setValue(v) {
+        this.value = v;
+    }
+}
+__decorate([
+    Field("lastModifiedOn"),
+    __metadata("design:type", Number)
+], PersistedCachedRecord.prototype, "lastModifiedOn", void 0);
+__decorate([
+    Field("value"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], PersistedCachedRecord.prototype, "setValue", null);
+class Cache {
+    constructor(decode, encode, persistStore, maxSize, expiryPeriod) {
+        this.decode = decode;
+        this.encode = encode;
+        this.persistStore = persistStore;
+        this.expiryPeriod = expiryPeriod;
+        this.memStore = new WatchableObject(maxSize, expiryPeriod);
+        if (persistStore) {
+            this.memStore.onDelete((k) => {
+                persistStore.remove(this.getTransformedKey(k)).schedule();
+            });
+            this.memStore.onSet((k, v) => __awaiter(this, void 0, void 0, function* () {
+                const record = new PersistedCachedRecord();
+                const result = this.encode(v);
+                if (result instanceof Promise || result instanceof Future) {
+                    record.value = yield result;
+                }
+                else {
+                    record.value = result;
+                }
+                record.lastModifiedOn = Date.now();
+                persistStore.set(this.getTransformedKey(k), record.json()).schedule();
+            }));
+            this.memStore.onClear(() => {
+                persistStore.clear().schedule();
+            });
+        }
+    }
+    get(key) {
+        return Future.of((resolve, reject, signal) => {
+            const value = this.memStore.get(key);
+            if (value === undefined && this.persistStore) {
+                const transformedKey = this.getTransformedKey(key);
+                resolve(this.persistStore
+                    .get(transformedKey)
+                    .thenApply(({ value }) => {
+                    if (value) {
+                        const val = PersistedCachedRecord.fromString(value, DataFormat.JSON);
+                        val.value = this.decode(val.value);
+                        return val;
+                    }
+                })
+                    .thenApply(({ value, signal }) => __awaiter(this, void 0, void 0, function* () {
+                    if (value) {
+                        if (this.expiryPeriod) {
+                            const remainingTime = Date.now() - value.lastModifiedOn - calculatePeriodValue(this.expiryPeriod);
+                            if (remainingTime <= 0) {
+                                yield this.persistStore.remove(transformedKey).registerSignal(signal);
+                                return;
+                            }
+                            this.memStore.set(key, value.value, { milliseconds: remainingTime });
+                        }
+                        else {
+                            this.memStore.set(key, value.value);
+                        }
+                    }
+                    return value === null || value === void 0 ? void 0 : value.value;
+                }))
+                    .registerSignal(signal));
+            }
+            resolve(value);
+        });
+    }
+    getSync(key) {
+        return this.memStore.get(key);
+    }
+    set(key, value) {
+        this.memStore.set(key, value);
+    }
+    remove(key) {
+        this.memStore.delete(key);
+    }
+    keys() {
+        var _a, _b;
+        return ((_b = (_a = this.persistStore) === null || _a === void 0 ? void 0 : _a.keys().map(this.getInversedKey)) !== null && _b !== void 0 ? _b : Stream.of(this.memStore.keys()));
+    }
+    keysSync() {
+        return this.memStore.keys();
+    }
+    values() {
+        var _a, _b;
+        return ((_b = (_a = this.persistStore) === null || _a === void 0 ? void 0 : _a.values().map((v) => PersistedCachedRecord.fromString(v, DataFormat.JSON)).map((v) => v.value)) !== null && _b !== void 0 ? _b : Stream.of(this.valuesSync()));
+    }
+    valuesSync() {
+        return this.memStore.values(true);
+    }
+    clear() {
+        this.memStore.clear();
+    }
+    [Symbol.asyncIterator]() {
+        const stream = this.keys()
+            .map((k) => this.get(k).thenApply(({ value }) => pair(k, value)))
+            .filter((v) => v.second !== undefined);
+        return stream[Symbol.asyncIterator]();
+    }
+    getTransformedKey(key) {
+        let transformedKey;
+        switch (typeof key) {
+            case "string":
+                transformedKey = "<string>" + key;
+                break;
+            case "number":
+                transformedKey = `<number>${key}`;
+                break;
+            case "boolean":
+                transformedKey = `<boolean>${key}`;
+                break;
+            case "object":
+                if (key instanceof Date) {
+                    transformedKey = "<iso>" + key.toISOString();
+                    break;
+                }
+                else if (Array.isArray(key)) {
+                    transformedKey = "<json>" + JSON.stringify(key);
+                    break;
+                }
+            default:
+                throw new Error("invalid key");
+        }
+        return transformedKey;
+    }
+    getInversedKey(transformedKey) {
+        let key;
+        const rawKey = transformedKey.substring(8);
+        switch (transformedKey.substring(0, 8)) {
+            case "<string>":
+                key = rawKey;
+                break;
+            case "<number>":
+                key = Number(rawKey);
+                break;
+            case "<bool  >":
+                key = (rawKey === "true");
+                break;
+            case "<date  >":
+                key = new Date(rawKey);
+                break;
+            case "<json  >":
+                key = JSON.parse(rawKey);
+                break;
+            default:
+                throw new Error("invalid key");
+        }
+        return key;
+    }
+}
+class CacheManager {
+    constructor(persistStore, maxSize, expiryPeriod) {
+        this.persistStore = persistStore;
+        this.maxSize = maxSize;
+        this.expiryPeriod = expiryPeriod;
+        this.memStores = new Map();
+    }
+    createCache(name, persist, encoder, decoder, maxSize, expiryPeriod) {
+        if (persist && (!encoder || !decoder)) {
+            throw new Error("encoder and decoder required for persisting data");
+        }
+        if (persist && !this.persistStore) {
+            throw new Error("store required for persisting data");
+        }
+        const cache = new Cache(decoder, encoder, persist ? this.persistStore : undefined, maxSize !== null && maxSize !== void 0 ? maxSize : this.maxSize, expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod);
+        this.memStores.set(name, cache);
+        return cache;
+    }
+    getCache(name) {
+        return this.memStores.get(name);
+    }
+    removeCache(name) {
+        const cache = this.memStores.get(name);
+        this.memStores.delete(name);
+        cache === null || cache === void 0 ? void 0 : cache.clear();
+    }
+}
+
+export { Cache, CacheManager };

package/data/store/web.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+var future = require('../../future/future.cjs');
+require('ramda');
+var stream = require('../../stream.cjs');
+var stream_state = require('../../stream/state.cjs');
+
+class LocalWebStore {
+    close() {
+        return future.Future.completed(null);
+    }
+    open() {
+        return future.Future.completed(null);
+    }
+    clear() {
+        return undefined;
+    }
+    get(key) {
+        return future.Future.of((resolve) => resolve(localStorage.getItem(key)));
+    }
+    keys() {
+        let index = -1;
+        return new stream.Stream(() => {
+            if (++index >= localStorage.length) {
+                return new stream_state.ExecutorState(true);
+            }
+            return localStorage.key(index);
+        });
+    }
+    length() {
+        return future.Future.of((resolve) => resolve(localStorage.length));
+    }
+    remove(key) {
+        return future.Future.of((resolve) => {
+            localStorage.removeItem(key);
+            resolve();
+        });
+    }
+    set(key, value) {
+        return future.Future.of((resolve) => {
+            localStorage.setItem(key, value);
+            resolve();
+        });
+    }
+    values() {
+        return this.keys().map((key) => localStorage.getItem(key));
+    }
+}
+class SessionWebStore {
+    close() {
+        return future.Future.completed(null);
+    }
+    open() {
+        return future.Future.completed(null);
+    }
+    clear() {
+        return undefined;
+    }
+    get(key) {
+        return future.Future.of((resolve) => resolve(sessionStorage.getItem(key)));
+    }
+    keys() {
+        let index = -1;
+        return new stream.Stream(() => {
+            if (++index >= sessionStorage.length) {
+                return new stream_state.ExecutorState(true);
+            }
+            return sessionStorage.key(index);
+        });
+    }
+    length() {
+        return future.Future.of((resolve) => resolve(sessionStorage.length));
+    }
+    remove(key) {
+        return future.Future.of((resolve) => {
+            sessionStorage.removeItem(key);
+            resolve();
+        });
+    }
+    set(key, value) {
+        return future.Future.of((resolve) => {
+            sessionStorage.setItem(key, value);
+            resolve();
+        });
+    }
+    values() {
+        return this.keys().map((key) => sessionStorage.getItem(key));
+    }
+}
+
+exports.LocalWebStore = LocalWebStore;
+exports.SessionWebStore = SessionWebStore;

package/data/store/web.d.ts

@@ -0,0 +1,25 @@
+import { PersistenceStore } from "./manager";
+import { Future } from "../../future";
+import { Stream } from "../../stream";
+export declare class LocalWebStore implements PersistenceStore {
+    close(): Future<void>;
+    open(): Future<void>;
+    clear(): Future<void>;
+    get(key: string): Future<string | undefined>;
+    keys(): Stream<string>;
+    length(): Future<number>;
+    remove(key: string): Future<void>;
+    set(key: string, value: string): Future<void>;
+    values(): Stream<string>;
+}
+export declare class SessionWebStore implements PersistenceStore {
+    close(): Future<void>;
+    open(): Future<void>;
+    clear(): Future<void>;
+    get(key: string): Future<string | undefined>;
+    keys(): Stream<string>;
+    length(): Future<number>;
+    remove(key: string): Future<void>;
+    set(key: string, value: string): Future<void>;
+    values(): Stream<string>;
+}

package/data/store/web.mjs

@@ -0,0 +1,89 @@
+import { Future } from '../../future/future.mjs';
+import 'ramda';
+import { Stream } from '../../stream.mjs';
+import { ExecutorState } from '../../stream/state.mjs';
+
+class LocalWebStore {
+    close() {
+        return Future.completed(null);
+    }
+    open() {
+        return Future.completed(null);
+    }
+    clear() {
+        return undefined;
+    }
+    get(key) {
+        return Future.of((resolve) => resolve(localStorage.getItem(key)));
+    }
+    keys() {
+        let index = -1;
+        return new Stream(() => {
+            if (++index >= localStorage.length) {
+                return new ExecutorState(true);
+            }
+            return localStorage.key(index);
+        });
+    }
+    length() {
+        return Future.of((resolve) => resolve(localStorage.length));
+    }
+    remove(key) {
+        return Future.of((resolve) => {
+            localStorage.removeItem(key);
+            resolve();
+        });
+    }
+    set(key, value) {
+        return Future.of((resolve) => {
+            localStorage.setItem(key, value);
+            resolve();
+        });
+    }
+    values() {
+        return this.keys().map((key) => localStorage.getItem(key));
+    }
+}
+class SessionWebStore {
+    close() {
+        return Future.completed(null);
+    }
+    open() {
+        return Future.completed(null);
+    }
+    clear() {
+        return undefined;
+    }
+    get(key) {
+        return Future.of((resolve) => resolve(sessionStorage.getItem(key)));
+    }
+    keys() {
+        let index = -1;
+        return new Stream(() => {
+            if (++index >= sessionStorage.length) {
+                return new ExecutorState(true);
+            }
+            return sessionStorage.key(index);
+        });
+    }
+    length() {
+        return Future.of((resolve) => resolve(sessionStorage.length));
+    }
+    remove(key) {
+        return Future.of((resolve) => {
+            sessionStorage.removeItem(key);
+            resolve();
+        });
+    }
+    set(key, value) {
+        return Future.of((resolve) => {
+            sessionStorage.setItem(key, value);
+            resolve();
+        });
+    }
+    values() {
+        return this.keys().map((key) => sessionStorage.getItem(key));
+    }
+}
+
+export { LocalWebStore, SessionWebStore };