@esportsplus/web-storage 0.3.5 → 0.4.0

package/build/constants.d.ts

@@ -1,5 +1,7 @@
 declare enum DriverType {
     IndexedDB = 0,
-    LocalStorage = 1
+    LocalStorage = 1,
+    Memory = 2,
+    SessionStorage = 3
 }
 export { DriverType };

package/build/constants.js

@@ -2,5 +2,7 @@ var DriverType;
 (function (DriverType) {
     DriverType[DriverType["IndexedDB"] = 0] = "IndexedDB";
     DriverType[DriverType["LocalStorage"] = 1] = "LocalStorage";
+    DriverType[DriverType["Memory"] = 2] = "Memory";
+    DriverType[DriverType["SessionStorage"] = 3] = "SessionStorage";
 })(DriverType || (DriverType = {}));
 export { DriverType };

package/build/drivers/memory.d.ts

@@ -0,0 +1,16 @@
+import type { Driver } from '../types.js';
+declare class MemoryDriver<T> implements Driver<T> {
+    private store;
+    constructor(name: string, _version: number);
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    delete(keys: (keyof T)[]): Promise<void>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    keys(): Promise<(keyof T)[]>;
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
+    only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>>;
+    replace(entries: [keyof T, T[keyof T]][]): Promise<void>;
+    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
+}
+export { MemoryDriver };

package/build/drivers/memory.js

@@ -0,0 +1,64 @@
+let stores = new Map();
+class MemoryDriver {
+    store;
+    constructor(name, _version) {
+        let existing = stores.get(name);
+        if (existing) {
+            this.store = existing;
+        }
+        else {
+            this.store = new Map();
+            stores.set(name, this.store);
+        }
+    }
+    async all() {
+        let result = {};
+        for (let [key, value] of this.store) {
+            result[key] = value;
+        }
+        return result;
+    }
+    async clear() {
+        this.store.clear();
+    }
+    async count() {
+        return this.store.size;
+    }
+    async delete(keys) {
+        for (let i = 0, n = keys.length; i < n; i++) {
+            this.store.delete(keys[i]);
+        }
+    }
+    async get(key) {
+        return this.store.get(key);
+    }
+    async keys() {
+        return [...this.store.keys()];
+    }
+    async map(fn) {
+        let i = 0;
+        for (let [key, value] of this.store) {
+            await fn(value, key, i++);
+        }
+    }
+    async only(keys) {
+        let results = new Map();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.store.get(keys[i]);
+            if (value !== undefined) {
+                results.set(keys[i], value);
+            }
+        }
+        return results;
+    }
+    async replace(entries) {
+        for (let i = 0, n = entries.length; i < n; i++) {
+            this.store.set(entries[i][0], entries[i][1]);
+        }
+    }
+    async set(key, value) {
+        this.store.set(key, value);
+        return true;
+    }
+}
+export { MemoryDriver };

package/build/drivers/sessionstorage.d.ts

@@ -0,0 +1,19 @@
+import type { Driver } from '../types.js';
+declare class SessionStorageDriver<T> implements Driver<T> {
+    private prefix;
+    constructor(name: string, version: number);
+    private getKeys;
+    private key;
+    private parse;
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    delete(keys: (keyof T)[]): Promise<void>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    keys(): Promise<(keyof T)[]>;
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
+    only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>>;
+    replace(entries: [keyof T, T[keyof T]][]): Promise<void>;
+    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
+}
+export { SessionStorageDriver };

package/build/drivers/sessionstorage.js

@@ -0,0 +1,94 @@
+class SessionStorageDriver {
+    prefix;
+    constructor(name, version) {
+        this.prefix = `${name}:${version}:`;
+    }
+    getKeys() {
+        let keys = [];
+        for (let i = 0, n = sessionStorage.length; i < n; i++) {
+            let key = sessionStorage.key(i);
+            if (key && key.startsWith(this.prefix)) {
+                keys.push(key.slice(this.prefix.length));
+            }
+        }
+        return keys;
+    }
+    key(key) {
+        return this.prefix + String(key);
+    }
+    parse(value) {
+        if (value === null) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async all() {
+        let keys = this.getKeys(), result = {};
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(sessionStorage.getItem(this.prefix + keys[i]));
+            if (value !== undefined) {
+                result[keys[i]] = value;
+            }
+        }
+        return result;
+    }
+    async clear() {
+        let keys = this.getKeys();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            sessionStorage.removeItem(this.prefix + keys[i]);
+        }
+    }
+    async count() {
+        return this.getKeys().length;
+    }
+    async delete(keys) {
+        for (let i = 0, n = keys.length; i < n; i++) {
+            sessionStorage.removeItem(this.key(keys[i]));
+        }
+    }
+    async get(key) {
+        return this.parse(sessionStorage.getItem(this.key(key)));
+    }
+    async keys() {
+        return this.getKeys();
+    }
+    async map(fn) {
+        let keys = this.getKeys();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(sessionStorage.getItem(this.prefix + keys[i]));
+            if (value !== undefined) {
+                await fn(value, keys[i], i);
+            }
+        }
+    }
+    async only(keys) {
+        let results = new Map();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(sessionStorage.getItem(this.key(keys[i])));
+            if (value !== undefined) {
+                results.set(keys[i], value);
+            }
+        }
+        return results;
+    }
+    async replace(entries) {
+        for (let i = 0, n = entries.length; i < n; i++) {
+            sessionStorage.setItem(this.key(entries[i][0]), JSON.stringify(entries[i][1]));
+        }
+    }
+    async set(key, value) {
+        try {
+            sessionStorage.setItem(this.key(key), JSON.stringify(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export { SessionStorageDriver };

package/build/index.d.ts

@@ -1,20 +1,30 @@
-import type { Filter, Options } from './types.js';
+import type { Filter, GlobalCallback, KeyCallback, Options, SetOptions } from './types.js';
 declare class Local<T> {
     private driver;
+    private globals;
+    private listeners;
+    private ready;
     private secret;
+    private version;
     constructor(options: Options, secret?: string);
     all(): Promise<T>;
     clear(): Promise<void>;
+    cleanup(): Promise<void>;
     count(): Promise<number>;
     delete(...keys: (keyof T)[]): Promise<void>;
     filter(fn: Filter<T>): Promise<T>;
     get(key: keyof T): Promise<T[keyof T] | undefined>;
+    get(key: keyof T, factory: () => T[keyof T] | Promise<T[keyof T]>): Promise<T[keyof T]>;
     keys(): Promise<(keyof T)[]>;
     length(): Promise<number>;
     map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
     only(...keys: (keyof T)[]): Promise<T>;
+    persist(key: keyof T): Promise<boolean>;
     replace(values: Partial<T>): Promise<string[]>;
-    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
+    set(key: keyof T, value: T[keyof T], options?: SetOptions): Promise<boolean>;
+    subscribe(callback: GlobalCallback<T>): () => void;
+    subscribe<K extends keyof T>(key: K, callback: KeyCallback<T, K>): () => void;
+    ttl(key: keyof T): Promise<number>;
 }
 declare const _default: <T>(options: Options, secret?: string) => Local<T>;
 export default _default;

package/build/index.js

@@ -2,6 +2,15 @@ import { decrypt, encrypt } from '@esportsplus/utilities';
 import { DriverType } from './constants.js';
 import { IndexedDBDriver } from './drivers/indexeddb.js';
 import { LocalStorageDriver } from './drivers/localstorage.js';
+import { MemoryDriver } from './drivers/memory.js';
+import { SessionStorageDriver } from './drivers/sessionstorage.js';
+const VERSION_KEY = '__version__';
+function isEnvelope(value) {
+    return value !== null
+        && typeof value === 'object'
+        && '__e' in value
+        && '__v' in value;
+}
 async function deserialize(value, secret) {
     if (value === undefined || value === null) {
         return undefined;
@@ -26,84 +35,267 @@ async function serialize(value, secret) {
     }
     return value;
 }
+function notify(globals, listeners, key, newValue, oldValue) {
+    let set = listeners.get(key);
+    if (set) {
+        for (let cb of set) {
+            cb(newValue, oldValue);
+        }
+    }
+    for (let cb of globals) {
+        cb(key, newValue, oldValue);
+    }
+}
+function unwrap(value) {
+    if (isEnvelope(value)) {
+        return {
+            expired: Date.now() > value.__e,
+            hasTTL: true,
+            value: value.__v
+        };
+    }
+    return { expired: false, hasTTL: false, value: value };
+}
+async function migrate(driver, migrations, version) {
+    let raw = await driver.get(VERSION_KEY), stored = typeof raw === 'number' ? raw : 0;
+    if (stored >= version) {
+        return;
+    }
+    let keys = Object.keys(migrations).map(Number).filter((v) => v > stored && v <= version).sort((a, b) => a - b);
+    for (let i = 0, n = keys.length; i < n; i++) {
+        let all = await driver.all(), data = {};
+        for (let key in all) {
+            if (key !== VERSION_KEY) {
+                data[key] = all[key];
+            }
+        }
+        let transformed = await migrations[keys[i]]({ all: () => Promise.resolve(data) });
+        await driver.clear();
+        let entries = [];
+        for (let key in transformed) {
+            entries.push([key, transformed[key]]);
+        }
+        if (entries.length > 0) {
+            await driver.replace(entries);
+        }
+    }
+    await driver.set(VERSION_KEY, version);
+}
 class Local {
     driver;
+    globals;
+    listeners;
+    ready;
     secret;
+    version;
     constructor(options, secret) {
+        this.globals = new Set();
+        this.listeners = new Map();
         this.secret = secret || null;
-        let { name, version = 1 } = options;
+        let { migrations, name, version = 1 } = options;
+        this.version = version;
         if (options.driver === DriverType.LocalStorage) {
             this.driver = new LocalStorageDriver(name, version);
         }
+        else if (options.driver === DriverType.Memory) {
+            this.driver = new MemoryDriver(name, version);
+        }
+        else if (options.driver === DriverType.SessionStorage) {
+            this.driver = new SessionStorageDriver(name, version);
+        }
         else {
             this.driver = new IndexedDBDriver(name, version);
         }
+        if (migrations) {
+            this.ready = migrate(this.driver, migrations, version);
+        }
+        else {
+            this.ready = Promise.resolve();
+        }
     }
     async all() {
-        let raw = await this.driver.all(), result = {};
+        await this.ready;
+        let expired = [], raw = await this.driver.all(), result = {};
         for (let key in raw) {
-            let value = await deserialize(raw[key], this.secret);
-            if (value !== undefined) {
-                result[key] = value;
+            if (key === VERSION_KEY) {
+                continue;
+            }
+            let deserialized = await deserialize(raw[key], this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                continue;
+            }
+            if (unwrapped.expired) {
+                expired.push(key);
+                continue;
             }
+            result[key] = unwrapped.value;
+        }
+        if (expired.length > 0) {
+            this.driver.delete(expired);
         }
         return result;
     }
     async clear() {
-        return this.driver.clear();
+        await this.ready;
+        let allData = await this.all(), keys = Object.keys(allData);
+        await this.driver.clear();
+        await this.driver.set(VERSION_KEY, this.version);
+        for (let i = 0, n = keys.length; i < n; i++) {
+            notify(this.globals, this.listeners, keys[i], undefined, allData[keys[i]]);
+        }
+    }
+    async cleanup() {
+        await this.ready;
+        let expired = [], oldValues = new Map();
+        await this.driver.map(async (raw, key) => {
+            if (key === VERSION_KEY) {
+                return;
+            }
+            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized !== undefined && unwrapped.expired) {
+                expired.push(key);
+                oldValues.set(key, unwrapped.value);
+            }
+        });
+        if (expired.length > 0) {
+            await this.driver.delete(expired);
+            for (let i = 0, n = expired.length; i < n; i++) {
+                notify(this.globals, this.listeners, expired[i], undefined, oldValues.get(expired[i]));
+            }
+        }
     }
     async count() {
-        return this.driver.count();
+        await this.ready;
+        let total = await this.driver.count(), raw = await this.driver.get(VERSION_KEY);
+        return raw !== undefined ? total - 1 : total;
     }
     async delete(...keys) {
-        return this.driver.delete(keys);
+        await this.ready;
+        let oldValues = new Map();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let raw = await this.driver.get(keys[i]), deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            oldValues.set(keys[i], deserialized === undefined ? undefined : unwrapped.value);
+        }
+        await this.driver.delete(keys);
+        for (let i = 0, n = keys.length; i < n; i++) {
+            notify(this.globals, this.listeners, keys[i], undefined, oldValues.get(keys[i]));
+        }
     }
     async filter(fn) {
-        let i = 0, result = {}, stop = () => { stopped = true; }, stopped = false;
+        await this.ready;
+        let expired = [], i = 0, result = {}, stop = () => { stopped = true; }, stopped = false;
         await this.driver.map(async (raw, key) => {
-            if (stopped) {
+            if (stopped || key === VERSION_KEY) {
                 return;
             }
-            let value = await deserialize(raw, this.secret);
-            if (value === undefined) {
+            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
                 return;
             }
-            if (await fn({ i: i++, key, stop, value })) {
-                result[key] = value;
+            if (unwrapped.expired) {
+                expired.push(key);
+                return;
+            }
+            if (await fn({ i: i++, key, stop, value: unwrapped.value })) {
+                result[key] = unwrapped.value;
             }
         });
+        if (expired.length > 0) {
+            this.driver.delete(expired);
+        }
         return result;
     }
-    async get(key) {
-        return deserialize(await this.driver.get(key), this.secret);
+    async get(key, factory) {
+        await this.ready;
+        let deserialized = await deserialize(await this.driver.get(key), this.secret), missing = false, unwrapped = unwrap(deserialized);
+        if (deserialized === undefined) {
+            missing = true;
+        }
+        else if (unwrapped.expired) {
+            this.driver.delete([key]);
+            missing = true;
+        }
+        if (missing) {
+            if (factory) {
+                let value = await factory();
+                this.set(key, value);
+                return value;
+            }
+            return undefined;
+        }
+        return unwrapped.value;
     }
     async keys() {
-        return this.driver.keys();
+        await this.ready;
+        let all = await this.driver.keys();
+        return all.filter((k) => k !== VERSION_KEY);
     }
-    length() {
-        return this.driver.count();
+    async length() {
+        await this.ready;
+        return this.count();
     }
-    map(fn) {
-        return this.driver.map(async (raw, key, i) => {
-            let value = await deserialize(raw, this.secret);
-            if (value !== undefined) {
-                await fn(value, key, i);
+    async map(fn) {
+        await this.ready;
+        let expired = [], j = 0;
+        await this.driver.map(async (raw, key) => {
+            if (key === VERSION_KEY) {
+                return;
+            }
+            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                return;
+            }
+            if (unwrapped.expired) {
+                expired.push(key);
+                return;
             }
+            await fn(unwrapped.value, key, j++);
         });
+        if (expired.length > 0) {
+            this.driver.delete(expired);
+        }
     }
     async only(...keys) {
-        let raw = await this.driver.only(keys), result = {};
+        await this.ready;
+        let expired = [], raw = await this.driver.only(keys), result = {};
         for (let [key, value] of raw) {
-            let deserialized = await deserialize(value, this.secret);
-            if (deserialized !== undefined) {
-                result[key] = deserialized;
+            let deserialized = await deserialize(value, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                continue;
             }
+            if (unwrapped.expired) {
+                expired.push(key);
+                continue;
+            }
+            result[key] = unwrapped.value;
+        }
+        if (expired.length > 0) {
+            this.driver.delete(expired);
         }
         return result;
     }
+    async persist(key) {
+        await this.ready;
+        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret);
+        if (deserialized === undefined) {
+            return false;
+        }
+        let unwrapped = unwrap(deserialized);
+        if (unwrapped.expired) {
+            this.driver.delete([key]);
+            return false;
+        }
+        if (!unwrapped.hasTTL) {
+            return true;
+        }
+        return this.driver.set(key, await serialize(unwrapped.value, this.secret));
+    }
     async replace(values) {
-        let entries = [], failed = [];
+        await this.ready;
+        let entries = [], failed = [], oldValues = new Map();
         for (let key in values) {
+            let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            oldValues.set(key, deserialized === undefined ? undefined : unwrapped.value);
             try {
                 entries.push([
                     key,
@@ -117,16 +309,64 @@ class Local {
         if (entries.length > 0) {
             await this.driver.replace(entries);
         }
+        for (let i = 0, n = entries.length; i < n; i++) {
+            let key = entries[i][0];
+            notify(this.globals, this.listeners, key, values[key], oldValues.get(key));
+        }
         return failed;
     }
-    async set(key, value) {
+    async set(key, value, options) {
+        await this.ready;
         try {
-            return this.driver.set(key, await serialize(value, this.secret));
+            let oldRaw = await this.driver.get(key), oldDeserialized = await deserialize(oldRaw, this.secret), oldUnwrapped = unwrap(oldDeserialized), oldValue = oldDeserialized === undefined ? undefined : oldUnwrapped.value, stored;
+            if (options?.ttl != null && options.ttl > 0) {
+                let envelope = {
+                    __e: Date.now() + options.ttl,
+                    __v: value
+                };
+                stored = await serialize(envelope, this.secret);
+            }
+            else {
+                stored = await serialize(value, this.secret);
+            }
+            let result = await this.driver.set(key, stored);
+            notify(this.globals, this.listeners, key, value, oldValue);
+            return result;
         }
         catch {
             return false;
         }
     }
+    subscribe(keyOrCallback, callback) {
+        if (typeof keyOrCallback === 'function') {
+            let cb = keyOrCallback;
+            this.globals.add(cb);
+            return () => { this.globals.delete(cb); };
+        }
+        let cb = callback, key = keyOrCallback, set = this.listeners.get(key);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(key, set);
+        }
+        set.add(cb);
+        return () => { set.delete(cb); };
+    }
+    async ttl(key) {
+        await this.ready;
+        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret);
+        if (deserialized === undefined) {
+            return -1;
+        }
+        if (!isEnvelope(deserialized)) {
+            return -1;
+        }
+        let remaining = deserialized.__e - Date.now();
+        if (remaining <= 0) {
+            this.driver.delete([key]);
+            return -1;
+        }
+        return remaining;
+    }
 }
 export default (options, secret) => {
     return new Local(options, secret);

package/build/types.d.ts

@@ -17,9 +17,23 @@ type Filter<T> = (data: {
     stop: VoidFunction;
     value: T[keyof T];
 }) => boolean | Promise<boolean>;
+type MigrationContext = {
+    all(): Promise<Record<string, unknown>>;
+};
+type MigrationFn = (old: MigrationContext) => Promise<Record<string, unknown>>;
 type Options = {
-    driver?: DriverType.IndexedDB | DriverType.LocalStorage;
+    driver?: DriverType.IndexedDB | DriverType.LocalStorage | DriverType.Memory | DriverType.SessionStorage;
+    migrations?: Record<number, MigrationFn>;
     name: string;
     version: number;
 };
-export type { Driver, Filter, Options };
+type SetOptions = {
+    ttl?: number;
+};
+type TTLEnvelope<V> = {
+    __e: number;
+    __v: V;
+};
+type GlobalCallback<T> = (key: keyof T, newValue: T[keyof T] | undefined, oldValue: T[keyof T] | undefined) => void;
+type KeyCallback<T, K extends keyof T = keyof T> = (newValue: T[K] | undefined, oldValue: T[K] | undefined) => void;
+export type { Driver, Filter, GlobalCallback, KeyCallback, MigrationContext, MigrationFn, Options, SetOptions, TTLEnvelope };

package/package.json

@@ -5,7 +5,10 @@
   },
   "description": "Web storage utility",
   "devDependencies": {
-    "@esportsplus/typescript": "^0.9.2"
+    "@esportsplus/typescript": "^0.9.2",
+    "fake-indexeddb": "^6.2.5",
+    "happy-dom": "^20.8.8",
+    "vitest": "^4.1.1"
   },
   "main": "build/index.js",
   "name": "@esportsplus/web-storage",
@@ -16,9 +19,10 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "scripts": {
     "build": "tsc && tsc-alias",
+    "test": "vitest run",
     "-": "-"
   }
 }

package/src/constants.ts

@@ -1,6 +1,8 @@
 enum DriverType {
     IndexedDB,
-    LocalStorage
+    LocalStorage,
+    Memory,
+    SessionStorage
 }
 
 export { DriverType };