@resolveio/client-lib-core 15.5.3 → 16.0.0

package/esm2022/lib/offline-db.mjs

@@ -0,0 +1,519 @@
+import { dateReviver } from './util/common.helper';
+export class StorageDB {
+    storage = null;
+    database = null;
+    primaryKey = null;
+    sep = '';
+    constructor(opts) {
+        opts = opts || {};
+        this.storage = opts.storage || window && window.localStorage;
+        this.database = opts.database || 'db';
+        this.primaryKey = opts.primaryKey || '_id';
+        this.sep = opts.sep || ':';
+        if (!isSupported(this.storage)) {
+            this.storage = null;
+        }
+    }
+    get(name, opts) {
+        return new Collection(this, name, opts);
+    }
+    getCollections() {
+        let collections = [];
+        Object.keys(this.storage).filter(a => a.split(':').length > 2).forEach(key => {
+            if (!collections.some(b => b === key.split(':')[1])) {
+                collections.push(key.split(':')[1]);
+            }
+        });
+        return collections;
+    }
+    collection(name, opts) {
+        return this.get(name, opts);
+    }
+}
+class Collection {
+    name = '';
+    storage = null;
+    path = '';
+    primaryKey = '';
+    cache = {};
+    cacheable = false;
+    constructor(db, name, opts) {
+        opts = opts || {};
+        this.name = name;
+        this.storage = db.storage || new MockStorage();
+        this.path = db.database + db.sep + name + db.sep;
+        this.primaryKey = opts.primaryKey || db.primaryKey;
+        this.cache = {};
+        this.cacheable = !db.storage;
+    }
+    _initCache() {
+        let cache = {};
+        let filterExp = new RegExp('^' + this.path);
+        for (let key of Object.keys(this.storage)) {
+            if (filterExp.test(key)) {
+                cache[key] = JSON.parse(this.storage.getItem(key), dateReviver);
+            }
+        }
+        this.cache = cache;
+        this.cacheable = true;
+    }
+    _filter(filter, opts) {
+        opts.type = opts.type || 'data'; // data, id;
+        opts.multi = opts.multi || false;
+        if (!this.cacheable) {
+            this._initCache();
+        }
+        let res = [];
+        let isFnFilter;
+        let isTypeId = opts.type === 'id';
+        if (typeof filter === 'string') {
+            filter = new RegExp(filter);
+        }
+        else if (typeof filter === 'function') {
+            isFnFilter = true;
+        }
+        else if (!filter) {
+            let ret = isTypeId ? Object.keys(this.cache) : Object.values(this.cache);
+            if (opts.multi) {
+                return ret;
+            }
+            else {
+                return ret[0] || null;
+            }
+        }
+        for (let key of Object.keys(this.cache)) {
+            let val = this.cache[key];
+            if (isFnFilter) {
+                if (filter(key, val['data'])) {
+                    let ret = isTypeId ? key : val;
+                    if (opts.multi) {
+                        res.push(ret);
+                    }
+                    else {
+                        return ret;
+                    }
+                }
+            }
+            else {
+                if (filter.test(key)) {
+                    let ret = isTypeId ? key : val;
+                    if (opts.multi) {
+                        res.push(ret);
+                    }
+                    else {
+                        return ret;
+                    }
+                }
+            }
+        }
+        return opts.multi ? res : null;
+    }
+    insert(data, expiresDate, opts) {
+        let arrayInsert = data instanceof Array;
+        if (arrayInsert) {
+            if (data.length === 0) {
+                return [];
+            }
+        }
+        else {
+            data = [data];
+        }
+        let pk = this.primaryKey;
+        let cacheable = this.cacheable;
+        for (let row of data) {
+            if (!isObject(row)) {
+                throw new Error('TypeError: insert data must be an object or an object array');
+            }
+            if (typeof row[pk] === 'undefined') {
+                row[pk] = new ID().toString();
+            }
+            let now = new Date();
+            if (cacheable) {
+                this.cache[this.path + row[pk]] = {
+                    offlineDate: now,
+                    offlineDateExpires: expiresDate ? expiresDate : new Date(now.getTime() + 604800000),
+                    data: row
+                };
+            }
+            this.storage.setItem(this.path + row[pk], JSON.stringify({
+                offlineDate: now,
+                offlineDateExpires: expiresDate ? expiresDate : new Date(now.getTime() + 604800000),
+                data: row
+            }));
+        }
+        return arrayInsert ? data.map(a => a._id) : data[0]._id;
+    }
+    find(query, opts, total) {
+        query = query || {};
+        opts = opts || {};
+        opts.skip = opts.skip || 0;
+        opts.limit = opts.limit;
+        opts.sort = opts.sort;
+        if (opts.sort instanceof Array) {
+            opts.sort = opts.sort.reduce((res, item) => {
+                if (typeof item === 'string') {
+                    res[item] = 1;
+                }
+                else if (item instanceof Array && item.length) {
+                    res[item[0]] = item[1] || 1;
+                }
+                return res;
+            }, {});
+        }
+        let data;
+        let ids = isObject(query) ? null : (query instanceof Array ? query : [query]);
+        let filterOpts = {
+            type: opts._filterType || 'data',
+            multi: true
+        };
+        if (ids) {
+            // by id array
+            let filterRegExp = new RegExp('^' + this.path + '(' + ids.join('|') + ')$');
+            data = this._filter(filterRegExp, filterOpts);
+        }
+        else if (Object.keys(query).length) {
+            // by query
+            data = this._filter((key, val) => {
+                return queryMatch(query, val);
+            }, filterOpts);
+        }
+        else {
+            data = this._filter(null, filterOpts);
+        }
+        if (!total) {
+            data = data.map(a => a.data);
+        }
+        // sort
+        if (opts.sort) {
+            data.sort((a, b) => {
+                return sortCompare(opts.sort, a, b);
+            });
+        }
+        if (opts.limit) {
+            data = data.slice(opts.skip, opts.skip + opts.limit);
+        }
+        else if (opts.skip) {
+            data = data.slice(opts.skip);
+        }
+        return data;
+    }
+    findOne(query, opts) {
+        query = query || {};
+        opts = opts || {};
+        let data;
+        let id = isObject(query) ? null : query;
+        let queryFields = isObject(query) ? Object.keys(query) : [];
+        let quickTarget = false;
+        let needsSort = !!opts.sort;
+        let filterOpts = {
+            type: opts._filterType || 'data',
+            multi: false
+        };
+        if (queryFields.length && queryFields.includes(this.primaryKey)) {
+            id = query[this.primaryKey];
+            quickTarget = true;
+        }
+        if (id) {
+            // by id
+            data = this.storage.getItem(this.path + id);
+            data = data ? JSON.parse(data, dateReviver).data : null;
+            if (data && quickTarget && !queryMatch(query, data)) {
+                return null;
+            }
+        }
+        else if (queryFields.length) {
+            // by query
+            if (needsSort) {
+                data = this.find(query, opts);
+            }
+            else {
+                data = this._filter((key, val) => {
+                    return queryMatch(query, val);
+                }, filterOpts);
+                if (Array.isArray(data)) {
+                    data = data.map(a => a.data);
+                }
+                else if (data) {
+                    data = data.data;
+                }
+            }
+        }
+        else {
+            if (needsSort) {
+                data = this.find(query, opts);
+            }
+            else {
+                data = this._filter(null, filterOpts);
+            }
+        }
+        if (!id && needsSort && data) {
+            data = data[0].data || null;
+        }
+        if (data && filterOpts.type === 'id') {
+            data = this.path + data[this.primaryKey];
+        }
+        return data;
+    }
+    remove(query, opts) {
+        if (!query) {
+            throw new Error('remove needs a query');
+        }
+        opts = opts || {};
+        opts.multi = (typeof opts.multi === 'undefined') ? true : opts.multi;
+        let findMethod = opts.multi ? 'find' : 'findOne';
+        let ids = null;
+        if (findMethod === 'find') {
+            ids = this[findMethod](query, {
+                _filterType: 'id'
+            }, true);
+        }
+        else {
+            ids = this[findMethod](query, {
+                _filterType: 'id'
+            });
+        }
+        let cacheable = this.cacheable;
+        if ((opts.multi && !ids.length) || (!opts.multi && !ids)) {
+            return 0;
+        }
+        if (!opts.multi) {
+            ids = [ids];
+        }
+        for (let id of ids) {
+            if (cacheable) {
+                delete this.cache[id];
+            }
+            this.storage.removeItem(id);
+        }
+        return ids.length;
+    }
+    update(query, values, opts) {
+        if (!query) {
+            throw new Error('update needs a query');
+        }
+        if (!values || !isObject(values)) {
+            throw new Error('update needs an object');
+        }
+        opts = opts || {};
+        opts.multi = (typeof opts.multi === 'undefined') ? false : opts.multi;
+        let findMethod = opts.multi ? 'find' : 'findOne';
+        let ids = this[findMethod](query, {
+            _filterType: 'id'
+        });
+        let pk = this.primaryKey;
+        let cacheable = this.cacheable;
+        if ((opts.multi && !ids.length) || (!opts.multi && !ids)) {
+            return 0;
+        }
+        if (!opts.multi) {
+            let id = ids;
+            let row = cacheable ? this.cache[id] : JSON.parse(this.storage.getItem(id), dateReviver);
+            let isIdUpdated = values[pk] && values[pk] !== row.data[pk];
+            let newId = isIdUpdated ? this.path + values[pk] : id;
+            // check exist
+            if (isIdUpdated && this.findOne(values[pk])) {
+                throw new Error('Duplicate value \'' + values[pk] + '\' for unique field \'' + pk + '\'');
+            }
+            let data = Object.assign({}, row.data, values);
+            if (cacheable) {
+                this.cache[newId] = {
+                    offlineDate: row.offlineDate,
+                    offlineDateExpires: row.offlineDateExpires,
+                    data: data
+                };
+                if (isIdUpdated) {
+                    delete this.cache[id];
+                }
+            }
+            this.storage.setItem(newId, JSON.stringify({
+                offlineDate: row.offlineDate,
+                offlineDateExpires: row.offlineDateExpires,
+                data: data
+            }));
+            if (isIdUpdated) {
+                this.storage.removeItem(id);
+            }
+            return data;
+        }
+        else {
+            delete values[pk];
+            if (!Object.keys(values).length) {
+                return 0;
+            }
+            for (let id of ids) {
+                let row = cacheable ? this.cache[id] : JSON.parse(this.storage.getItem(id), dateReviver);
+                let data = Object.assign({}, row.data, values);
+                if (cacheable) {
+                    this.cache[id] = {
+                        offlineDate: row.offlineDate,
+                        offlineDateExpires: row.offlineDateExpires,
+                        data: data
+                    };
+                }
+                this.storage.setItem(id, JSON.stringify({
+                    offlineDate: row.offlineDate,
+                    offlineDateExpires: row.offlineDateExpires,
+                    data: data
+                }));
+            }
+            return ids.length;
+        }
+    }
+    drop() {
+        this.remove({});
+        return true;
+    }
+}
+class ID {
+    constructor() {
+    }
+    toString() {
+        return (new Date().getTime() / 1000).toString(16).substr(-4) + Math.random().toString(16).substr(2, 12);
+    }
+}
+class MockStorage {
+    length = 0;
+    constructor() {
+        this.length = 0;
+    }
+    key() { }
+    setItem() { }
+    getItem() { }
+    removeItem() { }
+}
+const isSupported = (storage) => {
+    if (!storage || !(storage instanceof Object)) {
+        return false;
+    }
+    try {
+        storage.setItem('_supported', '1');
+        storage.removeItem('_supported');
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isObject = (object) => {
+    return object instanceof Object && object.constructor.name === 'Object';
+};
+const queryMatch = (query, target) => {
+    if (!query || !Object.keys(query).length) {
+        return true;
+    }
+    for (let field of Object.keys(query)) {
+        let val = query[field];
+        let tar = target[field];
+        if (!tar) {
+            field.split('.').forEach(path => {
+                if (!tar) {
+                    tar = target[path];
+                }
+                else {
+                    tar = tar[path];
+                }
+            });
+        }
+        if (val instanceof RegExp) {
+            if (!val.test(tar)) {
+                return false;
+            }
+        }
+        else if (isObject(val)) {
+            for (let op of Object.keys(val)) {
+                if (Operator._checkExist(op) && !Operator[op](val[op], tar)) {
+                    return false;
+                }
+            }
+        }
+        else if (val !== tar) {
+            return false;
+        }
+    }
+    return true;
+};
+const sortCompare = (sort, a, b, i, fields) => {
+    i = i || 0;
+    fields = fields || Object.keys(sort);
+    let field = fields[i];
+    if (!field) {
+        return 0;
+    }
+    if (a[field] === b[field]) {
+        i++;
+        return sortCompare(sort, a, b, i, fields);
+    }
+    if (sort[field] === 1) {
+        return a[field] - b[field];
+    }
+    if (sort[field] === -1) {
+        return b[field] - a[field];
+    }
+};
+/*
+    Query Selectors
+
+    $eq		Matches vals that are equal to a specified val.
+    $gt		Matches vals that are greater than a specified val.
+    $gte	Matches vals that are greater than or equal to a specified val.
+    $in		Matches any of the vals specified in an array.
+    $lt		Matches vals that are less than a specified val.
+    $lte	Matches vals that are less than or equal to a specified val.
+    $ne		Matches all vals that are not equal to a specified val.
+    $nin	Matches none of the vals specified in an array.
+*/
+const ops = ['$eq', '$gt', '$gte', '$in', '$lt', '$lte', '$ne', '$nin'];
+const isNotNumber = (val) => {
+    return typeof val !== 'number';
+};
+class Operator {
+    static $eq(val, tar) {
+        return tar === val;
+    }
+    static $gt(val, tar) {
+        if (isNotNumber(val)) {
+            throw new Error('\'$gt\' value must be a number');
+        }
+        return tar > val;
+    }
+    static $gte(val, tar) {
+        if (isNotNumber(val)) {
+            throw new Error('\'$gte\' value must be a number');
+        }
+        return tar >= val;
+    }
+    static $in(val, tar) {
+        if (!(val instanceof Array)) {
+            throw new Error('\'$in\' value must be an array');
+        }
+        return val.includes(tar);
+    }
+    static $lt(val, tar) {
+        if (isNotNumber(val)) {
+            throw new Error('\'$lt\' value must be a number');
+        }
+        return tar < val;
+    }
+    static $lte(val, tar) {
+        if (isNotNumber(val)) {
+            throw new Error('\'$lte\' value must be a number');
+        }
+        return tar <= val;
+    }
+    static $ne(val, tar) {
+        return tar !== val;
+    }
+    static $nin(val, tar) {
+        if (!(val instanceof Array)) {
+            throw new Error('\'$nin\' value must be an array');
+        }
+        return !val.includes(tar);
+    }
+    static _checkExist(op) {
+        if (ops.includes(op)) {
+            return true;
+        }
+        throw new Error('unknown operator: \'' + op + '\'');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"offline-db.js","sourceRoot":"","sources":["../../../../projects/core/src/lib/offline-db.ts"],"names":[],"mappings":"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","sourcesContent":["import { dateReviver } from './util/common.helper';\n\nexport class StorageDB {\n\n\tstorage = null;\n\tdatabase = null;\n\tprimaryKey = null;\n\tsep = '';\n\n\tconstructor (opts) {\n\t\topts = opts || {};\n\n\t\tthis.storage = opts.storage || window && window.localStorage;\n\t\tthis.database = opts.database || 'db';\n\t\tthis.primaryKey = opts.primaryKey || '_id';\n\t\tthis.sep = opts.sep || ':';\n\n\t\tif (!isSupported(this.storage)) {\n\t\t\tthis.storage = null;\n\t\t}\n\t}\n\n\tget(name, opts) {\n\t\treturn new Collection(this, name, opts);\n\t}\n\n\tgetCollections() {\n\t\tlet collections = [];\n\n\t\tObject.keys(this.storage).filter(a => a.split(':').length > 2).forEach(key => {\n\t\t\tif (!collections.some(b => b === key.split(':')[1])) {\n\t\t\t\tcollections.push(key.split(':')[1]);\n\t\t\t}\n\t\t});\n\n\t\treturn collections;\n\t}\n\n\tcollection(name, opts) {\n\t\treturn this.get(name, opts);\n\t}\n}\n\nclass Collection {\n\n\tname = '';\n\tstorage = null;\n\tpath = '';\n\tprimaryKey = '';\n\tcache = {};\n\tcacheable = false;\n\n\tconstructor (db, name, opts) {\n\t\topts = opts || {};\n\n\t\tthis.name = name;\n\t\tthis.storage = db.storage || new MockStorage();\n\t\tthis.path = db.database + db.sep + name + db.sep;\n\t\tthis.primaryKey = opts.primaryKey || db.primaryKey;\n\t\tthis.cache = {};\n\t\tthis.cacheable = !db.storage;\n\t}\n\n\n\t_initCache () {\n\t\tlet cache = {};\n\t\tlet filterExp = new RegExp('^' + this.path);\n\n\t\tfor (let key of Object.keys(this.storage)) {\n\t\t\tif (filterExp.test(key)) {\n\t\t\t\tcache[key] = JSON.parse(this.storage.getItem(key), dateReviver);\n\t\t\t}\n\t\t}\n\n\t\tthis.cache = cache;\n\t\tthis.cacheable = true;\n\t}\n\n\n\t_filter (filter, opts) {\n\t\topts.type = opts.type || 'data'; // data, id;\n\t\topts.multi = opts.multi || false;\n\n\t\tif (!this.cacheable) {\n\t\t\tthis._initCache();\n\t\t}\n\n\t\tlet res = [];\n\t\tlet isFnFilter;\n\t\tlet isTypeId = opts.type === 'id';\n\n\t\tif (typeof filter === 'string') {\n\t\t\tfilter = new RegExp(filter);\n\t\t} else if (typeof filter === 'function') {\n\t\t\tisFnFilter = true;\n\t\t} else if (!filter) {\n\t\t\tlet ret = isTypeId ? Object.keys(this.cache) : Object.values(this.cache);\n\n\t\t\tif (opts.multi) {\n\t\t\t\treturn ret;\n\t\t\t} else {\n\t\t\t\treturn ret[0] || null;\n\t\t\t}\n\t\t}\n\n\t\tfor (let key of Object.keys(this.cache)) {\n\t\t\tlet val = this.cache[key];\n\n\t\t\tif (isFnFilter) {\n\t\t\t\tif (filter(key, val['data'])) {\n\t\t\t\t\tlet ret = isTypeId ? key : val;\n\n\t\t\t\t\tif (opts.multi) {\n\t\t\t\t\t\tres.push(ret);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn ret;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (filter.test(key)) {\n\t\t\t\t\tlet ret = isTypeId ? key : val;\n\n\t\t\t\t\tif (opts.multi) {\n\t\t\t\t\t\tres.push(ret);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn ret;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn opts.multi ? res : null;\n\t}\n\n\n\tinsert(data, expiresDate?, opts?) {\n\t\tlet arrayInsert = data instanceof Array;\n\n\t\tif (arrayInsert) {\n\t\t\tif (data.length === 0) {\n\t\t\t\treturn [];\n\t\t\t}\n\t\t} else {\n\t\t\tdata = [data];\n\t\t}\n\n\t\tlet pk = this.primaryKey;\n\t\tlet cacheable = this.cacheable;\n\n\t\tfor (let row of data) {\n\t\t\tif (!isObject(row)) {\n\t\t\t\tthrow new Error('TypeError: insert data must be an object or an object array');\n\t\t\t}\n\n\t\t\tif (typeof row[pk] === 'undefined') {\n\t\t\t\trow[pk] = new ID().toString();\n\t\t\t}\n\n\t\t\tlet now = new Date();\n\n\t\t\tif (cacheable) {\n\t\t\t\tthis.cache[this.path + row[pk]] = {\n\t\t\t\t\tofflineDate: now,\n\t\t\t\t\tofflineDateExpires: expiresDate ? expiresDate : new Date(now.getTime() + 604800000),\n\t\t\t\t\tdata: row\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tthis.storage.setItem(this.path + row[pk], JSON.stringify({\n\t\t\t\tofflineDate: now,\n\t\t\t\tofflineDateExpires: expiresDate ? expiresDate : new Date(now.getTime() + 604800000),\n\t\t\t\tdata: row\n\t\t\t}));\n\t\t}\n\n\t\treturn arrayInsert ? data.map(a => a._id) : data[0]._id;\n\t}\n\n\n\tfind(query, opts?, total?) {\n\t\tquery = query || {};\n\t\topts = opts || {};\n\t\topts.skip = opts.skip || 0;\n\t\topts.limit = opts.limit;\n\t\topts.sort = opts.sort;\n\n\t\tif (opts.sort instanceof Array) {\n\t\t\topts.sort = opts.sort.reduce((res, item) => {\n\t\t\t\tif (typeof item === 'string') {\n\t\t\t\t\tres[item] = 1;\n\t\t\t\t} else if (item instanceof Array && item.length) {\n\t\t\t\t\tres[item[0]] = item[1] || 1;\n\t\t\t\t}\n\t\t\t\treturn res;\n\t\t\t}, {});\n\t\t}\n\n\t\tlet data;\n\t\tlet ids = isObject(query) ? null : (query instanceof Array ? query : [query]);\n\t\tlet filterOpts = {\n\t\t\ttype: opts._filterType || 'data',\n\t\t\tmulti: true\n\t\t};\n\n\t\tif (ids) {\n\t\t\t// by id array\n\t\t\tlet filterRegExp = new RegExp('^' + this.path + '(' + ids.join('|') + ')$');\n\t\t\tdata = this._filter(filterRegExp, filterOpts);\n\n\t\t} else if (Object.keys(query).length) {\n\t\t\t// by query\n\t\t\tdata = this._filter((key, val) => {\n\t\t\t\treturn queryMatch(query, val);\n\t\t\t}, filterOpts);\n\t\t} else {\n\t\t\tdata = this._filter(null, filterOpts);\n\t\t}\n\n\t\tif (!total) {\n\t\t\tdata = data.map(a => a.data);\n\t\t}\n\n\t\t// sort\n\t\tif (opts.sort) {\n\t\t\tdata.sort((a, b) => {\n\t\t\t\treturn sortCompare(opts.sort, a, b);\n\t\t\t});\n\t\t}\n\n\t\tif (opts.limit) {\n\t\t\tdata = data.slice(opts.skip, opts.skip + opts.limit);\n\t\t} else if (opts.skip) {\n\t\t\tdata = data.slice(opts.skip);\n\t\t}\n\n\t\treturn data;\n\t}\n\n\n\tfindOne(query, opts?) {\n\t\tquery = query || {};\n\t\topts = opts || {};\n\n\t\tlet data;\n\t\tlet id = isObject(query) ? null : query;\n\t\tlet queryFields = isObject(query) ? Object.keys(query) : [];\n\t\tlet quickTarget = false;\n\t\tlet needsSort = !!opts.sort;\n\t\tlet filterOpts = {\n\t\t\ttype: opts._filterType || 'data',\n\t\t\tmulti: false\n\t\t};\n\n\t\tif (queryFields.length && queryFields.includes(this.primaryKey)) {\n\t\t\tid = query[this.primaryKey];\n\t\t\tquickTarget = true;\n\t\t}\n\n\t\tif (id) {\n\t\t\t// by id\n\t\t\tdata = this.storage.getItem(this.path + id);\n\t\t\tdata = data ? JSON.parse(data, dateReviver).data : null;\n\n\t\t\tif (data && quickTarget && !queryMatch(query, data)) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t} else if (queryFields.length) {\n\t\t\t// by query\n\t\t\tif (needsSort) {\n\t\t\t\tdata = this.find(query, opts);\n\t\t\t} else {\n\t\t\t\tdata = this._filter((key, val) => {\n\t\t\t\t\treturn queryMatch(query, val);\n\t\t\t\t}, filterOpts);\n\n\t\t\t\tif (Array.isArray(data)) {\n\t\t\t\t\tdata = data.map(a => a.data);\n\t\t\t\t}\n\t\t\t\telse if (data) {\n\t\t\t\t\tdata = data.data;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (needsSort) {\n\t\t\t\tdata = this.find(query, opts);\n\t\t\t} else {\n\t\t\t\tdata = this._filter(null, filterOpts);\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (!id && needsSort && data) {\n\t\t\tdata = data[0].data || null;\n\t\t}\n\n\t\tif (data && filterOpts.type === 'id') {\n\t\t\tdata = this.path + data[this.primaryKey];\n\t\t}\n\n\t\treturn data;\n\t}\n\n\n\tremove(query, opts?) {\n\t\tif (!query) {\n\t\t\tthrow new Error('remove needs a query');\n\t\t}\n\n\t\topts = opts || {};\n\t\topts.multi = (typeof opts.multi === 'undefined') ? true : opts.multi;\n\n\t\tlet findMethod = opts.multi ? 'find' : 'findOne';\n\t\tlet ids = null;\n\t\tif (findMethod === 'find') {\n\t\t\tids = this[findMethod](query, {\n\t\t\t\t_filterType: 'id'\n\t\t\t}, true);\n\t\t}\n\t\telse {\n\t\t\tids = this[findMethod](query, {\n\t\t\t\t_filterType: 'id'\n\t\t\t});\n\t\t}\n\t\tlet cacheable = this.cacheable;\n\n\t\tif ((opts.multi && !ids.length) || (!opts.multi && !ids)) {\n\t\t\treturn 0;\n\t\t}\n\n\t\tif (!opts.multi) {\n\t\t\tids = [ids];\n\t\t}\n\n\t\tfor (let id of ids) {\n\t\t\tif (cacheable) {\n\t\t\t\tdelete this.cache[id];\n\t\t\t}\n\n\t\t\tthis.storage.removeItem(id);\n\t\t}\n\n\t\treturn ids.length;\n\t}\n\n\n\tupdate(query, values, opts?) {\n\t\tif (!query) {\n\t\t\tthrow new Error('update needs a query');\n\t\t}\n\t\tif (!values || !isObject(values)) {\n\t\t\tthrow new Error('update needs an object');\n\t\t}\n\n\t\topts = opts || {};\n\t\topts.multi = (typeof opts.multi === 'undefined') ? false : opts.multi;\n\n\t\tlet findMethod = opts.multi ? 'find' : 'findOne';\n\t\tlet ids = this[findMethod](query, {\n\t\t\t_filterType: 'id'\n\t\t});\n\t\tlet pk = this.primaryKey;\n\t\tlet cacheable = this.cacheable;\n\n\t\tif ((opts.multi && !ids.length) || (!opts.multi && !ids)) {\n\t\t\treturn 0;\n\t\t}\n\n\t\tif (!opts.multi) {\n\t\t\tlet id = ids;\n\t\t\tlet row = cacheable ? this.cache[id] : JSON.parse(this.storage.getItem(id), dateReviver);\n\t\t\tlet isIdUpdated = values[pk] && values[pk] !== row.data[pk];\n\t\t\tlet newId = isIdUpdated ? this.path + values[pk] : id;\n\n\t\t\t// check exist\n\t\t\tif (isIdUpdated && this.findOne(values[pk])) {\n\t\t\t\tthrow new Error('Duplicate value \\'' + values[pk] + '\\' for unique field \\'' + pk + '\\'');\n\t\t\t}\n\n\t\t\tlet data = Object.assign({}, row.data, values);\n\n\t\t\tif (cacheable) {\n\t\t\t\tthis.cache[newId] = {\n\t\t\t\t\tofflineDate: row.offlineDate,\n\t\t\t\t\tofflineDateExpires: row.offlineDateExpires,\n\t\t\t\t\tdata: data\n\t\t\t\t};\n\t\t\t\tif (isIdUpdated) {\n\t\t\t\t\tdelete this.cache[id];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tthis.storage.setItem(newId, JSON.stringify({\n\t\t\t\tofflineDate: row.offlineDate,\n\t\t\t\tofflineDateExpires: row.offlineDateExpires,\n\t\t\t\tdata: data\n\t\t\t}));\n\n\t\t\tif (isIdUpdated) {\n\t\t\t\tthis.storage.removeItem(id);\n\t\t\t}\n\n\t\t\treturn data;\n\n\t\t} else {\n\t\t\tdelete values[pk];\n\n\t\t\tif (!Object.keys(values).length) {\n\t\t\t\treturn 0;\n\t\t\t}\n\n\t\t\tfor (let id of ids) {\n\t\t\t\tlet row = cacheable ? this.cache[id] : JSON.parse(this.storage.getItem(id), dateReviver);\n\n\t\t\t\tlet data = Object.assign({}, row.data, values);\n\n\t\t\t\tif (cacheable) {\n\t\t\t\t\tthis.cache[id] = {\n\t\t\t\t\t\tofflineDate: row.offlineDate,\n\t\t\t\t\t\tofflineDateExpires: row.offlineDateExpires,\n\t\t\t\t\t\tdata: data\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\tthis.storage.setItem(id, JSON.stringify({\n\t\t\t\t\tofflineDate: row.offlineDate,\n\t\t\t\t\tofflineDateExpires: row.offlineDateExpires,\n\t\t\t\t\tdata: data\n\t\t\t\t}));\n\t\t\t}\n\n\t\t\treturn ids.length;\n\t\t}\n\t}\n\n\tdrop() {\n\t\tthis.remove({});\n\t\treturn true;\n\t}\n}\n\nclass ID {\n\tconstructor() {\n\t}\n\n\ttoString() {\n\t\treturn (new Date().getTime() / 1000).toString(16).substr(-4) + Math.random().toString(16).substr(2, 12);\n\t}\n}\n\nclass MockStorage {\n\tlength = 0;\n\n\tconstructor () {\n\t\tthis.length = 0;\n\t}\n\n\tkey() {}\n\tsetItem() {}\n\tgetItem() {}\n\tremoveItem() {}\n}\n\nconst isSupported = (storage) => {\n\tif (!storage || !(storage instanceof Object)) {\n\t\treturn false;\n\t}\n\n\ttry {\n\t\tstorage.setItem('_supported', '1');\n\t\tstorage.removeItem('_supported');\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nconst isObject = (object) => {\n\treturn object instanceof Object && object.constructor.name === 'Object';\n};\n\nconst queryMatch = (query, target) => {\n\tif (!query || !Object.keys(query).length) {\n\t\treturn true;\n\t}\n\n\tfor (let field of Object.keys(query)) {\n\t\tlet val = query[field];\n\t\tlet tar = target[field];\n\n\t\tif (!tar) {\n\t\t\tfield.split('.').forEach(path => {\n\t\t\t\tif (!tar) {\n\t\t\t\t\ttar = target[path];\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\ttar = tar[path];\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tif (val instanceof RegExp) {\n\t\t\tif (!val.test(tar)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} else if (isObject(val)) {\n\t\t\tfor (let op of Object.keys(val)) {\n\t\t\t\tif (Operator._checkExist(op) && !Operator[op](val[op], tar)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (val !== tar) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n};\n\nconst sortCompare = (sort, a, b, i?, fields?) => {\n\ti = i || 0;\n\tfields = fields || Object.keys(sort);\n\n\tlet field = fields[i];\n\n\tif (!field) {\n\t\treturn 0;\n\t}\n\n\tif (a[field] === b[field]) {\n\t\ti++;\n\t\treturn sortCompare(sort, a, b, i, fields);\n\t}\n\n\tif (sort[field] === 1) {\n\t\treturn a[field] - b[field];\n\t}\n\n\tif (sort[field] === -1) {\n\t\treturn b[field] - a[field];\n\t}\n};\n\n/*\n\tQuery Selectors\n\n\t$eq\t\tMatches vals that are equal to a specified val.\n\t$gt\t\tMatches vals that are greater than a specified val.\n\t$gte\tMatches vals that are greater than or equal to a specified val.\n\t$in\t\tMatches any of the vals specified in an array.\n\t$lt\t\tMatches vals that are less than a specified val.\n\t$lte\tMatches vals that are less than or equal to a specified val.\n\t$ne\t\tMatches all vals that are not equal to a specified val.\n\t$nin\tMatches none of the vals specified in an array.\n*/\n\nconst ops = ['$eq', '$gt', '$gte', '$in', '$lt', '$lte', '$ne', '$nin'];\n\nconst isNotNumber = (val) => {\n\treturn typeof val !== 'number';\n};\n\nclass Operator {\n\tstatic $eq(val, tar) {\n\t\treturn tar === val;\n\t}\n\n\tstatic $gt(val, tar) {\n\t\tif (isNotNumber(val)) {\n\t\t\tthrow new Error('\\'$gt\\' value must be a number');\n\t\t}\n\t\treturn tar > val;\n\t}\n\n\tstatic $gte(val, tar) {\n\t\tif (isNotNumber(val)) {\n\t\t\tthrow new Error('\\'$gte\\' value must be a number');\n\t\t}\n\t\treturn tar >= val;\n\t}\n\n\tstatic $in(val, tar) {\n\t\tif (!(val instanceof Array)) {\n\t\t\tthrow new Error('\\'$in\\' value must be an array');\n\t\t}\n\t\treturn val.includes(tar);\n\t}\n\n\tstatic $lt(val, tar) {\n\t\tif (isNotNumber(val)) {\n\t\t\tthrow new Error('\\'$lt\\' value must be a number');\n\t\t}\n\t\treturn tar < val;\n\t}\n\n\tstatic $lte(val, tar) {\n\t\tif (isNotNumber(val)) {\n\t\t\tthrow new Error('\\'$lte\\' value must be a number');\n\t\t}\n\t\treturn tar <= val;\n\t}\n\n\tstatic $ne(val, tar) {\n\t\treturn tar !== val;\n\t}\n\n\tstatic $nin(val, tar) {\n\t\tif (!(val instanceof Array)) {\n\t\t\tthrow new Error('\\'$nin\\' value must be an array');\n\t\t}\n\t\treturn !val.includes(tar);\n\t}\n\n\tstatic _checkExist(op) {\n\t\tif (ops.includes(op)) {\n\t\t\treturn true;\n\t\t}\n\t\tthrow new Error('unknown operator: \\'' + op + '\\'');\n\t}\n}"]}