@esportsplus/web-storage 0.1.44 → 0.3.1

package/src/drivers/indexeddb.ts

@@ -0,0 +1,183 @@
+import type { Driver } from '~/types';
+
+
+let connections = new Map<string, Promise<IDBDatabase>>();
+
+
+function connect(name: string, version: number): Promise<IDBDatabase> {
+    let key = `${name}:${version}`;
+
+    if (!connections.has(key)) {
+        connections.set(key, new Promise((resolve, reject) => {
+            let request = indexedDB.open(name, version);
+
+            request.onupgradeneeded = () => {
+                let db = request.result;
+
+                if (!db.objectStoreNames.contains(name)) {
+                    db.createObjectStore(name);
+                }
+            };
+
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        }));
+    }
+
+    return connections.get(key)!;
+}
+
+function promisify<T>(request: IDBRequest<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+
+
+class IndexedDBDriver<T> implements Driver<T> {
+
+    private connection: Promise<IDBDatabase>;
+
+    private name: string;
+
+
+    constructor(name: string, version: number) {
+        this.connection = connect(name, version);
+        this.name = name;
+    }
+
+
+    async all(): Promise<T> {
+        let db = await this.connection,
+            store = db.transaction(this.name, 'readonly').objectStore(this.name),
+            [keys, values] = await Promise.all([
+                promisify(store.getAllKeys()),
+                promisify(store.getAll())
+            ]),
+            result = {} as T;
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            result[keys[i] as keyof T] = values[i];
+        }
+
+        return result;
+    }
+
+    async clear(): Promise<void> {
+        let db = await this.connection,
+            store = db.transaction(this.name, 'readwrite').objectStore(this.name);
+
+        await promisify(store.clear());
+    }
+
+    async count(): Promise<number> {
+        let db = await this.connection,
+            store = db.transaction(this.name, 'readonly').objectStore(this.name);
+
+        return promisify(store.count());
+    }
+
+    async delete(keys: (keyof T)[]): Promise<void> {
+        let db = await this.connection,
+            tx = db.transaction(this.name, 'readwrite'),
+            store = tx.objectStore(this.name);
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            store.delete(keys[i] as IDBValidKey);
+        }
+
+        return new Promise((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+
+    async get(key: keyof T): Promise<T[keyof T] | undefined> {
+        let db = await this.connection,
+            store = db.transaction(this.name, 'readonly').objectStore(this.name);
+
+        return promisify(store.get(key as IDBValidKey));
+    }
+
+    async keys(): Promise<(keyof T)[]> {
+        let db = await this.connection,
+            store = db.transaction(this.name, 'readonly').objectStore(this.name);
+
+        return promisify(store.getAllKeys()) as Promise<(keyof T)[]>;
+    }
+
+    async map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void> {
+        let db = await this.connection,
+            store = db.transaction(this.name, 'readonly').objectStore(this.name);
+
+        return new Promise((resolve, reject) => {
+            let cursor = store.openCursor(),
+                i = 0;
+
+            cursor.onerror = () => reject(cursor.error);
+            cursor.onsuccess = async () => {
+                let c = cursor.result;
+
+                if (c) {
+                    await fn(c.value, c.key as keyof T, i++);
+                    c.continue();
+                }
+                else {
+                    resolve();
+                }
+            };
+        });
+    }
+
+    async only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>> {
+        let db = await this.connection,
+            results = new Map<keyof T, T[keyof T]>(),
+            tx = db.transaction(this.name, 'readonly'),
+            store = tx.objectStore(this.name);
+
+        await Promise.all(
+            keys.map((key) =>
+                promisify(store.get(key as IDBValidKey)).then((value) => {
+                    if (value !== undefined) {
+                        results.set(key, value);
+                    }
+                })
+            )
+        );
+
+        return results;
+    }
+
+    async replace(entries: [keyof T, T[keyof T]][]): Promise<void> {
+        let db = await this.connection,
+            tx = db.transaction(this.name, 'readwrite'),
+            store = tx.objectStore(this.name);
+
+        for (let i = 0; i < entries.length; i++) {
+            store.put(entries[i][1], entries[i][0] as IDBValidKey);
+        }
+
+        return new Promise((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+
+    async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
+        try {
+            let db = await this.connection,
+                store = db.transaction(this.name, 'readwrite').objectStore(this.name);
+
+            await promisify(store.put(value, key as IDBValidKey));
+
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+
+export { IndexedDBDriver };

package/src/drivers/localstorage.ts

@@ -0,0 +1,131 @@
+import type { Driver } from '~/types';
+
+
+class LocalStorageDriver<T> implements Driver<T> {
+
+    private prefix: string;
+
+
+    constructor(name: string, version: number) {
+        this.prefix = `${name}:${version}:`;
+    }
+
+
+    private getKeys(): string[] {
+        let keys: string[] = [];
+
+        for (let i = 0, n = localStorage.length; i < n; i++) {
+            let key = localStorage.key(i);
+
+            if (key && key.startsWith(this.prefix)) {
+                keys.push(key.slice(this.prefix.length));
+            }
+        }
+
+        return keys;
+    }
+
+    private key(key: keyof T): string {
+        return this.prefix + String(key);
+    }
+
+    private parse(value: string | null): unknown {
+        if (value === null) {
+            return undefined;
+        }
+
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+
+
+    async all(): Promise<T> {
+        let keys = this.getKeys(),
+            result = {} as T;
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(localStorage.getItem(this.prefix + keys[i]));
+
+            if (value !== undefined) {
+                result[keys[i] as keyof T] = value as T[keyof T];
+            }
+        }
+
+        return result;
+    }
+
+    async clear(): Promise<void> {
+        let keys = this.getKeys();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            localStorage.removeItem(this.prefix + keys[i]);
+        }
+    }
+
+    async count(): Promise<number> {
+        return this.getKeys().length;
+    }
+
+    async delete(keys: (keyof T)[]): Promise<void> {
+        for (let i = 0, n = keys.length; i < n; i++) {
+            localStorage.removeItem(this.key(keys[i]));
+        }
+    }
+
+    async get(key: keyof T): Promise<T[keyof T] | undefined> {
+        return this.parse(localStorage.getItem(this.key(key))) as T[keyof T] | undefined;
+    }
+
+    async keys(): Promise<(keyof T)[]> {
+        return this.getKeys() as (keyof T)[];
+    }
+
+    async map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void> {
+        let keys = this.getKeys();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(localStorage.getItem(this.prefix + keys[i]));
+
+            if (value !== undefined) {
+                await fn(value as T[keyof T], keys[i] as keyof T, i);
+            }
+        }
+    }
+
+    async only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>> {
+        let results = new Map<keyof T, T[keyof T]>();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(localStorage.getItem(this.key(keys[i])));
+
+            if (value !== undefined) {
+                results.set(keys[i], value as T[keyof T]);
+            }
+        }
+
+        return results;
+    }
+
+    async replace(entries: [keyof T, T[keyof T]][]): Promise<void> {
+        for (let i = 0, n = entries.length; i < n; i++) {
+            localStorage.setItem(this.key(entries[i][0]), JSON.stringify(entries[i][1]));
+        }
+    }
+
+    async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
+        try {
+            localStorage.setItem(this.key(key), JSON.stringify(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+
+export { LocalStorageDriver };

package/src/index.ts

@@ -1 +1,192 @@
-export { default as local } from './local';
+import { decrypt, encrypt } from '@esportsplus/crypto';
+import type { Driver, Filter, Options } from './types';
+import { DriverType } from './constants';
+import { IndexedDBDriver } from '~/drivers/indexeddb';
+import { LocalStorageDriver } from '~/drivers/localstorage';
+
+
+async function deserialize<V>(value: unknown, secret: string | null): Promise<V | undefined> {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+
+    if (secret && typeof value === 'string') {
+        try {
+            value = await decrypt(value, secret);
+            value = JSON.parse(value as string);
+        }
+        catch {
+            return undefined;
+        }
+    }
+
+    return value as V;
+}
+
+async function serialize<V>(value: V, secret: string | null): Promise<string | V> {
+    if (value === undefined || value === null) {
+        return value;
+    }
+
+    if (secret) {
+        return encrypt(JSON.stringify(value), secret);
+    }
+
+    return value;
+}
+
+
+class Local<T> {
+
+    private driver: Driver<T>;
+
+    private secret: string | null;
+
+
+    constructor(options: Options, secret?: string) {
+        this.secret = secret || null;
+
+        let { name, version = 1 } = options;
+
+        if (options.driver === DriverType.LocalStorage) {
+            this.driver = new LocalStorageDriver<T>(name, version);
+        }
+        else {
+            this.driver = new IndexedDBDriver<T>(name, version);
+        }
+    }
+
+
+    async all(): Promise<T> {
+        let raw = await this.driver.all(),
+            result = {} as T;
+
+        for (let key in raw) {
+            let value = await deserialize<T[keyof T]>(raw[key], this.secret);
+
+            if (value !== undefined) {
+                (result as Record<string, unknown>)[key] = value;
+            }
+        }
+
+        return result;
+    }
+
+    async clear(): Promise<void> {
+        return this.driver.clear();
+    }
+
+    async count(): Promise<number> {
+        return this.driver.count();
+    }
+
+    async delete(...keys: (keyof T)[]): Promise<void> {
+        return this.driver.delete(keys);
+    }
+
+    async filter(fn: Filter<T>): Promise<T> {
+        let i = 0,
+            result = {} as T,
+            stop = () => { stopped = true; },
+            stopped = false;
+
+        await this.driver.map(async (raw, key) => {
+            if (stopped) {
+                return;
+            }
+
+            let value = await deserialize<T[keyof T]>(raw, this.secret);
+
+            if (value === undefined) {
+                return;
+            }
+
+            if (await fn({ i: i++, key, stop, value })) {
+                result[key] = value;
+            }
+        });
+
+        return result;
+    }
+
+    async get(key: keyof T): Promise<T[keyof T] | undefined> {
+        return deserialize<T[keyof T]>(
+            await this.driver.get(key),
+            this.secret
+        );
+    }
+
+    async keys(): Promise<(keyof T)[]> {
+        return this.driver.keys();
+    }
+
+    length(): Promise<number> {
+        return this.driver.count();
+    }
+
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void> {
+        return this.driver.map(async (raw, key, i) => {
+            let value = await deserialize<T[keyof T]>(raw, this.secret);
+
+            if (value !== undefined) {
+                await fn(value, key, i);
+            }
+        });
+    }
+
+    async only(...keys: (keyof T)[]): Promise<T> {
+        let raw = await this.driver.only(keys),
+            result = {} as T;
+
+        for (let [key, value] of raw) {
+            let deserialized = await deserialize<T[keyof T]>(value, this.secret);
+
+            if (deserialized !== undefined) {
+                result[key] = deserialized;
+            }
+        }
+
+        return result;
+    }
+
+    async replace(values: Partial<T>): Promise<string[]> {
+        let entries: [keyof T, unknown][] = [],
+            failed: string[] = [];
+
+        for (let key in values) {
+            try {
+                entries.push([
+                    key,
+                    await serialize(values[key], this.secret)
+                ]);
+            }
+            catch {
+                failed.push(key);
+            }
+        }
+
+        if (entries.length > 0) {
+            await this.driver.replace(entries as [keyof T, T[keyof T]][]);
+        }
+
+        return failed;
+    }
+
+    async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
+        try {
+            return this.driver.set(
+                key,
+                await serialize(value, this.secret) as T[keyof T]
+            );
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+
+export default <T>(options: Options, secret?: string) => {
+    return new Local<T>(options, secret);
+};
+export { DriverType } from './constants';

package/src/types.ts

@@ -1,23 +1,26 @@
-import localforage from 'localforage';
+import { DriverType } from './constants';
 
 
-enum Driver {
-    IndexedDB,
-    LocalStorage
-};
-
-type Filter<T> = (data: { i: number, key: keyof T, stop: VoidFunction, value: T[keyof T] }) => boolean | Promise<boolean>;
+interface Driver<T> {
+    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>;
+}
 
-type LocalForage = typeof localforage;
+type Filter<T> = (data: { i: number; key: keyof T; stop: VoidFunction; value: T[keyof T] }) => boolean | Promise<boolean>;
 
 type Options = {
-    description?: string;
-    driver?: string | string[];
+    driver?: DriverType.IndexedDB | DriverType.LocalStorage;
     name: string;
-    size?: number;
-    version?: number;
+    version: number;
 };
 
 
-export { Driver };
-export type { Filter, LocalForage, Options };
+export type { Driver, Filter, Options };

package/build/local.d.ts

@@ -1,19 +0,0 @@
-import { Filter, LocalForage, Options } from './types.js';
-declare class Local<T> {
-    instance: LocalForage;
-    iterate: LocalForage['iterate'];
-    keys: LocalForage['keys'];
-    length: LocalForage['length'];
-    secret: null | string;
-    constructor(options: Options, secret?: string);
-    all(): Promise<T>;
-    clear(): Promise<void>;
-    delete(...keys: (keyof T)[]): Promise<void>;
-    filter(fn: Filter<T>): Promise<T>;
-    get(key: keyof T): Promise<unknown>;
-    only(...keys: (keyof T)[]): Promise<T>;
-    replace(values: T): Promise<string[]>;
-    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
-}
-declare const _default: <T>(options: Options, secret?: string) => Local<T>;
-export default _default;

package/build/local.js

@@ -1,119 +0,0 @@
-import { Driver } from './types.js';
-import { decrypt, encrypt } from '@esportsplus/crypto';
-import localforage from 'localforage';
-async function deserialize(value, secret = null) {
-    if (secret && typeof value === 'string') {
-        value = await decrypt(value, secret);
-    }
-    if (typeof value === 'string') {
-        value = JSON.parse(value);
-    }
-    return value;
-}
-async function serialize(value, secret = null) {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    value = JSON.stringify(value);
-    if (secret) {
-        value = await encrypt(value, secret);
-    }
-    return value;
-}
-class Local {
-    instance;
-    iterate;
-    keys;
-    length;
-    secret = null;
-    constructor(options, secret) {
-        switch ((options.driver || Driver.IndexedDB)) {
-            case Driver.LocalStorage:
-                options.driver = localforage.LOCALSTORAGE;
-                break;
-            default:
-                options.driver = localforage.INDEXEDDB;
-                break;
-        }
-        this.instance = localforage.createInstance(Object.assign(options, { storeName: options.name }));
-        this.iterate = this.instance.iterate;
-        this.keys = this.instance.keys;
-        this.length = this.instance.length;
-        if (secret) {
-            this.secret = secret;
-        }
-    }
-    async all() {
-        let stack = [], values = {};
-        await this.instance.iterate((v, k) => {
-            stack.push(deserialize(v, this.secret)
-                .then((value) => {
-                if (value === undefined) {
-                    return;
-                }
-                values[k] = value;
-            })
-                .catch(() => { }));
-        });
-        await Promise.allSettled(stack);
-        return values;
-    }
-    async clear() {
-        await this.instance.clear();
-    }
-    async delete(...keys) {
-        let stack = [];
-        for (let i = 0, n = keys.length; i < n; i++) {
-            stack.push(this.instance.removeItem(keys[i]));
-        }
-        await Promise.allSettled(stack);
-    }
-    async filter(fn) {
-        let stop = () => {
-            stopped = true;
-        }, stopped = false, values = {};
-        await this.instance.iterate(async (v, k, i) => {
-            let key = k, value = await deserialize(v, this.secret).catch(() => undefined);
-            if (value === undefined) {
-                return;
-            }
-            if (await fn({ i, key, stop, value })) {
-                values[key] = value;
-            }
-            if (stopped) {
-                return true;
-            }
-        });
-        return values;
-    }
-    async get(key) {
-        return await deserialize(await this.instance.getItem(key), this.secret).catch(() => undefined);
-    }
-    async only(...keys) {
-        return await this.filter(({ key }) => keys.includes(key));
-    }
-    async replace(values) {
-        let failed = [], stack = [];
-        for (let key in values) {
-            stack.push(this.set(key, values[key])
-                .then((ok) => {
-                if (ok) {
-                    return;
-                }
-                failed.push(key);
-            }));
-        }
-        await Promise.allSettled(stack);
-        return failed;
-    }
-    async set(key, value) {
-        let ok = true;
-        await this.instance.setItem(key, await serialize(value, this.secret)
-            .catch(() => {
-            ok = false;
-            return undefined;
-        }));
-        return ok;
-    }
-}
-export default (options, secret) => new Local(options, secret);