@esportsplus/web-storage 0.1.26 → 0.1.28

package/build/local.d.ts

@@ -1,18 +1,21 @@
-import { LocalForage, Options } from './types';
+import { Filter, LocalForage, Options } from './types';
 declare class Local<T> {
     instance: LocalForage;
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
     length: LocalForage['length'];
-    constructor(options: Options);
-    all(): Promise<T | Record<string, never>>;
+    secret: null | string;
+    constructor(options: Options, secret?: string);
+    private deserialize;
+    private serialize;
+    all(): Promise<T>;
     clear(): Promise<void>;
     delete(...keys: (keyof T)[]): Promise<void>;
-    filter(filter: Function): Promise<T | Record<string, never>>;
-    get(key: keyof T): Promise<(T[keyof T] & {}) | undefined>;
-    only(...keys: (keyof T)[]): Promise<T | Record<string, never>>;
-    replace(values: T): Promise<void>;
-    set(key: keyof T, value: T[keyof T]): Promise<void>;
+    filter(fn: Filter<T>): Promise<T>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    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) => Local<T>;
+declare const _default: <T>(options: Options, secret?: string) => Local<T>;
 export default _default;

package/build/local.js

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

package/build/types.d.ts

@@ -3,6 +3,12 @@ declare enum Driver {
     IndexedDB = 0,
     LocalStorage = 1
 }
+type Filter<T> = (data: {
+    i: number;
+    key: keyof T;
+    stop: VoidFunction;
+    value: T[keyof T];
+}) => boolean | Promise<boolean>;
 type LocalForage = typeof localforage;
 type Options = {
     description?: string;
@@ -11,4 +17,4 @@ type Options = {
     size?: number;
     version?: number;
 };
-export { Driver, LocalForage, Options };
+export { Driver, Filter, LocalForage, Options };

package/package.json

@@ -1,11 +1,12 @@
 {
     "author": "ICJR",
     "dependencies": {
+        "@esportsplus/crypto": "^0.0.4",
         "localforage": "^1.10.0"
     },
     "description": "Web storage utility",
     "devDependencies": {
-        "@esportsplus/webpack": "^0.0.81"
+        "@esportsplus/webpack": "^0.0.97"
     },
     "main": "build/index.js",
     "name": "@esportsplus/web-storage",
@@ -17,5 +18,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.26"
+    "version": "0.1.28"
 }

package/src/local.ts

@@ -1,4 +1,5 @@
-import { Driver, LocalForage, Options } from './types';
+import { Driver, Filter, LocalForage, Options } from '~/types';
+import { decrypt, encrypt } from '@esportsplus/crypto';
 import localforage from 'localforage';
 
 
@@ -7,36 +8,79 @@ class Local<T> {
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
     length: LocalForage['length'];
+    secret: null | string = null;
 
 
-    constructor(options: Options) {
-        let driver;
-
+    constructor(options: Options, secret?: string) {
         switch ((options.driver || Driver.IndexedDB) as Driver) {
             case Driver.LocalStorage:
-                driver = localforage.LOCALSTORAGE;
+                options.driver = localforage.LOCALSTORAGE;
                 break;
             default:
-                driver = localforage.INDEXEDDB;
+                options.driver = localforage.INDEXEDDB;
                 break;
         }
 
         this.instance = localforage.createInstance(
-            Object.assign(options, { driver, storeName: options.name })
+            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;
+        }
+    }
+
+
+    private async deserialize(value: unknown) {
+        if (this.secret && typeof value === 'string') {
+            value = await decrypt(value, this.secret);
+        }
+
+        if (typeof value === 'string') {
+            value = JSON.parse(value);
+        }
+
+        return value as T[keyof T];
+    }
+
+    private async serialize(value: unknown) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+
+        value = JSON.stringify(value);
+
+        if (this.secret) {
+            value = await encrypt(value as string, this.secret);
+        }
+
+        return value as string;
     }
 
 
-    async all(): Promise<T | Record<string, never>> {
-        let values: T = {} as T;
+    async all(): Promise<T> {
+        let stack: Promise<void>[] = [],
+            values: T = {} as T;
 
-        await this.instance.iterate((value: any, key: string) => {
-            values[key as keyof T] = value;
+        await this.instance.iterate((v: unknown, k: string) => {
+            stack.push(
+                this.deserialize(v)
+                    .then((value) => {
+                        if (value === undefined) {
+                            return;
+                        }
+
+                        values[k as keyof T] = value;
+                    })
+                    .catch(() => {})
+            )
         });
 
+        await Promise.allSettled(stack);
+
         return values;
     }
 
@@ -45,30 +89,37 @@ class Local<T> {
     }
 
     async delete(...keys: (keyof T)[]) {
-        if (!keys.length) {
-            return;
-        }
+        let stack: Promise<void>[] = [];
 
         for (let i = 0, n = keys.length; i < n; i++) {
-            await this.instance.removeItem(keys[i] as string);
+            stack.push( this.instance.removeItem(keys[i] as string) );
         }
+
+        await Promise.allSettled(stack);
     }
 
-    async filter(filter: Function): Promise<T | Record<string, never>> {
-        let s: VoidFunction = () => {
-                stop = true;
+    async filter(fn: Filter<T>): Promise<T> {
+        let stop: VoidFunction = () => {
+                stopped = true;
             },
-            stop: boolean = false,
+            stopped: boolean = false,
             values: T = {} as T;
 
-        await this.instance.iterate((value: any, key: string, i: number) => {
-            if (filter({ i, key, stop: s, value })) {
-                values[key as keyof T] = value;
+        await this.instance.iterate(async (v, k, i) => {
+            let key = k as keyof T,
+                value = await this.deserialize(v).catch(() => undefined);
+
+            if (value === undefined) {
+                return;
+            }
+
+            if (await fn({ i, key, stop, value })) {
+                values[key] = value;
             }
 
             // LocalForage iterate will stop once a non
             // undefined value is returned
-            if (stop) {
+            if (stopped) {
                 return true;
             }
         });
@@ -77,29 +128,49 @@ class Local<T> {
     }
 
     async get(key: keyof T) {
-        let value: T[keyof T] | null = await this.instance.getItem(key as string);
-
-        if (value === null) {
-            return undefined;
-        }
-
-        return value;
+        return await this.deserialize( await this.instance.getItem(key as string) ).catch(() => undefined);
     }
 
     async only(...keys: (keyof T)[]) {
-        return await this.filter((key: string) => keys.includes(key as keyof T));
+        return await this.filter(({ key }) => keys.includes(key));
     }
 
     async replace(values: T) {
+        let failed: string[] = [],
+            stack: Promise<void>[] = [];
+
         for (let key in values) {
-            await this.instance.setItem(key, values[key]);
+            stack.push(
+                this.set(key, values[key])
+                    .then((ok) => {
+                        if (ok) {
+                            return;
+                        }
+
+                        failed.push(key);
+                    })
+            );
         }
+
+        await Promise.allSettled(stack);
+
+        return failed;
     }
 
     async set(key: keyof T, value: T[keyof T]) {
-        await this.instance.setItem(key as string, value);
+        let ok = true;
+
+        await this.instance.setItem(
+            key as string,
+            await this.serialize(value).catch(() => {
+                ok = false;
+                return undefined;
+            })
+        );
+
+        return ok;
     }
 }
 
 
-export default <T>(options: Options) => new Local<T>(options);
+export default <T>(options: Options, secret?: string) => new Local<T>(options, secret);

package/src/types.ts

@@ -6,6 +6,8 @@ enum Driver {
     LocalStorage
 };
 
+type Filter<T> = (data: { i: number, key: keyof T, stop: VoidFunction, value: T[keyof T] }) => boolean | Promise<boolean>;
+
 type LocalForage = typeof localforage;
 
 type Options = {
@@ -17,4 +19,4 @@ type Options = {
 };
 
 
-export { Driver, LocalForage, Options };
+export { Driver, Filter, LocalForage, Options };

package/build/local/index.d.ts

@@ -1,20 +0,0 @@
-import { LocalForage, Options } from './types';
-declare class Store<T> {
-    instance: LocalForage;
-    iterate: LocalForage['iterate'];
-    keys: LocalForage['keys'];
-    length: LocalForage['length'];
-    constructor(options: Options);
-    all(): Promise<T | Record<string, never>>;
-    clear(): Promise<void>;
-    delete(...keys: (keyof T)[]): Promise<void>;
-    filter(filter: Function): Promise<T | Record<string, never>>;
-    get(key: keyof T): Promise<(T[keyof T] & {}) | undefined>;
-    only(...keys: (keyof T)[]): Promise<T | Record<string, never>>;
-    replace(values: T): Promise<void>;
-    set(key: keyof T, value: T[keyof T]): Promise<void>;
-}
-declare const _default: {
-    store: <T>(options: Options) => Store<T>;
-};
-export default _default;

package/build/local/index.js

@@ -1,76 +0,0 @@
-import { Driver } from './types';
-import localforage from 'localforage';
-class Store {
-    instance;
-    iterate;
-    keys;
-    length;
-    constructor(options) {
-        let driver;
-        switch ((options.driver || Driver.IndexedDB)) {
-            case Driver.LocalStorage:
-                driver = localforage.LOCALSTORAGE;
-                break;
-            default:
-                driver = localforage.INDEXEDDB;
-                break;
-        }
-        this.instance = localforage.createInstance(Object.assign(options, { driver, storeName: options.name }));
-        this.iterate = this.instance.iterate;
-        this.keys = this.instance.keys;
-        this.length = this.instance.length;
-    }
-    async all() {
-        let values = {};
-        await this.instance.iterate((value, key) => {
-            values[key] = value;
-        });
-        return values;
-    }
-    async clear() {
-        await this.instance.clear();
-    }
-    async delete(...keys) {
-        if (!keys.length) {
-            return;
-        }
-        for (let i = 0, n = keys.length; i < n; i++) {
-            await this.instance.removeItem(keys[i]);
-        }
-    }
-    async filter(filter) {
-        let s = () => {
-            stop = true;
-        }, stop = false, values = {};
-        await this.instance.iterate((value, key, i) => {
-            if (filter({ i, key, stop: s, value })) {
-                values[key] = value;
-            }
-            if (stop) {
-                return true;
-            }
-        });
-        return values;
-    }
-    async get(key) {
-        let value = await this.instance.getItem(key);
-        if (value === null) {
-            return undefined;
-        }
-        return value;
-    }
-    async only(...keys) {
-        return await this.filter((key) => keys.includes(key));
-    }
-    async replace(values) {
-        for (let key in values) {
-            await this.instance.setItem(key, values[key]);
-        }
-    }
-    async set(key, value) {
-        await this.instance.setItem(key, value);
-    }
-}
-export default {
-    store: (options) => new Store(options)
-};

package/build/local/types.d.ts

@@ -1,14 +0,0 @@
-import localforage from 'localforage';
-declare enum Driver {
-    IndexedDB = 0,
-    LocalStorage = 1
-}
-type LocalForage = typeof localforage;
-type Options = {
-    description?: string;
-    driver?: string | string[];
-    name: string;
-    size?: number;
-    version?: number;
-};
-export { Driver, LocalForage, Options };

package/build/local/types.js

@@ -1,7 +0,0 @@
-var Driver;
-(function (Driver) {
-    Driver[Driver["IndexedDB"] = 0] = "IndexedDB";
-    Driver[Driver["LocalStorage"] = 1] = "LocalStorage";
-})(Driver || (Driver = {}));
-;
-export { Driver };

package/build/memory/index.d.ts

@@ -1,16 +0,0 @@
-declare class Store<T> {
-    store: T;
-    constructor(data: T);
-    all(): {} & T;
-    clear(): void;
-    delete(key: keyof T): void;
-    filter(filter: Function): Promise<T | Record<string, never>>;
-    get(key: keyof T): T[keyof T];
-    only(...keys: (keyof T)[]): T;
-    replace(values: T): void;
-    set(key: keyof T, value: T[keyof T]): void;
-}
-declare const _default: {
-    store: <T>(data: T) => Store<T>;
-};
-export default _default;

package/build/memory/index.js

@@ -1,51 +0,0 @@
-class Store {
-    store;
-    constructor(data) {
-        this.store = data;
-    }
-    all() {
-        return Object.assign({}, this.store);
-    }
-    clear() {
-        this.store = {};
-    }
-    delete(key) {
-        delete this.store[key];
-    }
-    async filter(filter) {
-        let s = () => {
-            stop = true;
-        }, stop = false, values = {};
-        for (let key in this.store) {
-            let value = this.store[key];
-            if (await filter({ key, stop: s, value })) {
-                values[key] = value;
-            }
-            if (stop) {
-                break;
-            }
-        }
-        return values;
-    }
-    get(key) {
-        return this.store[key];
-    }
-    only(...keys) {
-        let data = {};
-        for (let i = 0, n = keys.length; i < n; i++) {
-            data[keys[i]] = this.store[keys[i]];
-        }
-        return data;
-    }
-    replace(values) {
-        for (let key in values) {
-            this.store[key] = values[key];
-        }
-    }
-    set(key, value) {
-        this.store[key] = value;
-    }
-}
-export default {
-    store: (data) => new Store(data)
-};