xdriver 2.0.1 → 2.0.3

package/lib/table.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { _copy, _instance, Logger } from "./com";
+import { Logger } from "./com";
 const logger = Logger.getLogger('Table');
 const _getObjectStore = (table, mode = 'readonly') => {
     var _a;
@@ -33,19 +33,163 @@ const _request = (request) => __awaiter(void 0, void 0, void 0, function* () {
         };
     });
 });
+export class RowPacket extends Array {
+    constructor(rows = []) {
+        super(...rows);
+    }
+    distinct(column) {
+        if (!column) {
+            return this;
+        }
+        let set = new Set();
+        return this.filter(row => {
+            let union = null;
+            if (column !== void 0) {
+                union = typeof column === 'function' ? column(row) : row[column];
+            }
+            else {
+                union = row;
+            }
+            if (!set.has(union)) {
+                set.add(union);
+                return true;
+            }
+            return false;
+        });
+    }
+    mapping(keyFn, valFn) {
+        if (!keyFn)
+            throw new Error('Undefined group by field');
+        let mapping = new Map();
+        this.forEach((item, index, array) => {
+            let unionKey = keyFn.call(this, item, index, array);
+            if (mapping.has(unionKey)) {
+                throw new Error(`${unionKey} duplicate error`);
+            }
+            mapping.set(unionKey, valFn ? valFn(item, index, array) : item);
+        });
+        return mapping;
+    }
+    group(key, valFn) {
+        if (!key)
+            throw new Error('Undefined group by field');
+        let group = new Map();
+        this.forEach((item, index, array) => {
+            var _a;
+            let unionKey = typeof key === 'function' ? key.call(this, item, index, array) : item[key];
+            let value = valFn ? valFn(item, index, this) : item;
+            if (!group.has(unionKey)) {
+                group.set(unionKey, [value]);
+            }
+            else {
+                (_a = group.get(unionKey)) === null || _a === void 0 ? void 0 : _a.push(value);
+            }
+        });
+        return group;
+    }
+    max(keyFn) {
+        let max = 0;
+        let maxRows = [];
+        this.forEach((item, index, array) => {
+            let unionKey = typeof keyFn === 'function' ? keyFn.call(this, item, index, array) : item[keyFn];
+            if (unionKey > max) {
+                max = unionKey;
+                maxRows = [item];
+            }
+            else if (unionKey === max) {
+                maxRows.push(item);
+            }
+        });
+        return {
+            value: max,
+            rows: maxRows
+        };
+    }
+    min(keyFn) {
+        let min = 0;
+        let minRows = [];
+        this.forEach((item, index, array) => {
+            let unionKey = typeof keyFn === 'function' ? keyFn.call(this, item, index, array) : item[keyFn];
+            if (unionKey < min) {
+                min = unionKey;
+                minRows = [item];
+            }
+            else if (unionKey === min) {
+                minRows.push(item);
+            }
+        });
+        return {
+            value: min,
+            rows: minRows
+        };
+    }
+    sum(keyFn) {
+        return this.reduce((sum, item, index, array) => {
+            return sum + (typeof keyFn === 'function' ? keyFn.call(this, item, index, array) : item[keyFn]);
+        }, 0);
+    }
+    average(keyFn) {
+        return this.sum(keyFn) / this.length;
+    }
+}
+export class Pagination {
+    constructor(data, pageSize = 10, pageIndex = 1) {
+        this._data = data;
+        this._pageSize = pageSize < 1 ? 10 : pageSize;
+        this._pageIndex = pageIndex < 0 ? 1 : pageIndex;
+        this._total = data.length;
+    }
+    get totalPage() {
+        return Math.ceil(this._total / this._pageSize);
+    }
+    get total() {
+        return this._total;
+    }
+    get pageIndex() {
+        return this._pageIndex;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    get hasNext() {
+        return this._pageIndex * this._pageSize < this._total;
+    }
+    get hasPrev() {
+        return this._pageIndex > 1;
+    }
+    get data() {
+        let start = (this._pageIndex - 1) * this._pageSize;
+        let end = start + this._pageSize;
+        return this._data.slice(start, end);
+    }
+    prev() {
+        if (this.hasPrev) {
+            this._pageIndex--;
+            return true;
+        }
+        return false;
+    }
+    next() {
+        if (this.hasNext) {
+            this._pageIndex++;
+            return true;
+        }
+        return false;
+    }
+}
 export default class Table {
     constructor(table, database) {
         this.primaryKey = "id";
         this.autoIncrement = false;
         this.indexes = [];
-        let metadata;
+        let tableMeta;
         if (typeof table === 'string') {
-            metadata = { name: table };
+            tableMeta = { name: table };
         }
         else {
-            metadata = Object.assign({}, table);
+            tableMeta = Object.assign({}, table);
         }
-        const { name = '', primaryKey = 'id', autoIncrement = true, indexes = [] } = metadata;
+        const { name = '', primaryKey = 'id', autoIncrement = true, indexes = [] } = tableMeta;
         this.name = name;
         this.primaryKey = primaryKey;
         this.autoIncrement = autoIncrement;
@@ -54,6 +198,14 @@ export default class Table {
             return Object.assign({ unique: false, multiEntry: false }, idx);
         });
     }
+    get meta() {
+        return {
+            name: this.name,
+            primaryKey: this.primaryKey,
+            autoIncrement: this.autoIncrement,
+            indexes: this.indexes
+        };
+    }
     insert(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const store = _getObjectStore(this, 'readwrite');
@@ -66,34 +218,12 @@ export default class Table {
             return results;
         });
     }
-    update(modify, key, count) {
+    update(modify, key) {
         return __awaiter(this, void 0, void 0, function* () {
             const store = _getObjectStore(this, 'readwrite');
-            if (!key || !_instance(key, IDBKeyRange)) {
-                return _request(store.put(modify, key));
-            }
-            let rows = yield _request(store.getAll(key, count));
-            rows = _instance(rows, Array) ? rows : [rows];
-            let results = [];
-            for (let row of rows) {
-                let rs = yield _request(store.put(_copy(modify, row)));
-                results.push(rs);
-            }
-            return results;
+            return _request(store.put(modify, key));
         });
     }
-    merge(row) {
-        let { primaryKey } = this;
-        let keys = Array.isArray(primaryKey) ? primaryKey : [primaryKey];
-        let keyArray = [];
-        for (let key of keys) {
-            keyArray.push(row[key]);
-        }
-        if (keyArray.length) {
-            return this.update(row, keyArray);
-        }
-        return this.insert(row);
-    }
     delete(key) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!key) {
@@ -105,7 +235,7 @@ export default class Table {
             return rows;
         });
     }
-    clear() {
+    truncate() {
         return _request(_getObjectStore(this, 'readwrite').clear());
     }
     dropIndex(name) {
@@ -118,66 +248,90 @@ export default class Table {
         return _request(_getObjectStore(this).count(key));
     }
     query(key, count) {
-        return _request(_getObjectStore(this).getAll(key, count));
+        return __awaiter(this, void 0, void 0, function* () {
+            let rows = yield _request(_getObjectStore(this).getAll(key, count));
+            return new RowPacket(rows);
+        });
+    }
+    queryByIndex(indexName, key, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = _getObjectStore(this);
+            const index = store.index(indexName);
+            let rows = yield _request(index.getAll(key || null, count));
+            return new RowPacket(rows);
+        });
     }
-    select(key, count, index) {
-        if (!index) {
+    select(key, count, indexName) {
+        if (!indexName) {
             return this.query(key, count);
         }
-        return this.queryByIndex(index, key, count);
+        return this.queryByIndex(indexName, key, count);
     }
     queryByKey(key) {
-        return _request(_getObjectStore(this).get(key));
-    }
-    fetch(key, direction) {
         return __awaiter(this, void 0, void 0, function* () {
+            let rows = yield _request(_getObjectStore(this).get(key));
+            return new RowPacket(rows);
+        });
+    }
+    paginate() {
+        return __awaiter(this, arguments, void 0, function* (pageNo = 1, pageSize = 10, key, indexName) {
             const store = _getObjectStore(this);
-            let cursor = yield _request(store.openCursor(key, direction));
-            if (!cursor) {
-                return [];
+            let request;
+            let count = pageSize * pageNo;
+            if (indexName) {
+                const index = store.index(indexName);
+                request = index.getAll(key, count);
             }
-            let rows = [];
-            while (cursor.value) {
-                rows.push(cursor.value);
-                cursor.continue();
+            else {
+                request = store.getAll(key, count);
             }
-            return rows;
+            let rows = yield _request(request);
+            return new RowPacket(rows.slice(pageSize * (pageNo - 1), pageSize * pageNo));
         });
     }
-    queryByIndex(indexName, key, count) {
-        const store = _getObjectStore(this);
-        const index = store.index(indexName);
-        return _request(index.getAll(key || null, count));
-    }
-    deplete(key_1) {
-        return __awaiter(this, arguments, void 0, function* (key, direction = 'next') {
-            const store = _getObjectStore(this, 'readwrite');
-            const cursor = yield _request(store.openCursor(key, direction));
-            if (!cursor) {
-                return [];
-            }
-            let rows = [];
-            while (cursor.value) {
-                rows.push(cursor.value);
-                cursor.continue();
-            }
-            return rows;
+    queryById(id, indexName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [result] = yield this.select(IDBKeyRange.only(id), 1, indexName);
+            return result;
         });
     }
-    multiple(indexName_1, key_1) {
-        return __awaiter(this, arguments, void 0, function* (indexName, key, direction = 'next') {
+    scan(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, direction = 'next', indexName) {
             const store = _getObjectStore(this);
-            const index = store.index(indexName);
-            const cursor = yield _request(index.openCursor(key, direction));
-            if (!cursor) {
-                return [];
+            let request;
+            if (!indexName) {
+                request = store.openCursor(key, direction);
             }
-            let rows = [];
-            while (cursor.value) {
-                rows.push(cursor.value);
-                cursor.continue();
+            else {
+                request = store.index(indexName).openCursor(key, direction);
             }
-            return rows;
+            return new Promise((resolve, reject) => {
+                let packets = new RowPacket([]);
+                request.onsuccess = function (event) {
+                    const req = event.target;
+                    const cursor = req.result;
+                    if (cursor) {
+                        packets.push(cursor.value);
+                        cursor.continue();
+                    }
+                    else {
+                        resolve(packets);
+                    }
+                };
+                request.onerror = function (event) {
+                    reject(event);
+                };
+            });
+        });
+    }
+    getAllData() {
+        const store = _getObjectStore(this);
+        return _request(store.getAll());
+    }
+    getPagination() {
+        return __awaiter(this, arguments, void 0, function* (pageSize = 10, pageIndex = 1) {
+            const rows = yield this.getAllData();
+            return new Pagination(rows, pageSize, pageIndex);
         });
     }
 }

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/com.ts","../src/const.ts","../src/database.ts","../src/driver.ts","../src/index.ts","../src/table.ts"],"version":"5.9.3"}
+{"root":["../src/com.ts","../src/connection.ts","../src/const.ts","../src/database.ts","../src/index.ts","../src/table.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xdriver",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "A simple driver for IndexDB",
   "main": "./lib/index",
   "files": [

package/lib/driver.d.ts

@@ -1,14 +0,0 @@
-import Database from "./database";
-import { Row, Rows } from "./table";
-export default class Driver extends Database {
-    insert(table: string, data: Array<Record<string, any>>): Promise<any[]> | undefined;
-    query(table: string, query?: IDBValidKey | IDBKeyRange, count?: number): Promise<Rows> | undefined;
-    select(table: string, key?: IDBValidKey | IDBKeyRange, index?: string, count?: number): Promise<Rows> | undefined;
-    selectByKey(table: string, key: IDBValidKey | IDBKeyRange): Promise<Row> | undefined;
-    count(table: string, key: IDBValidKey | IDBKeyRange): Promise<number> | undefined;
-    update(table: string, modify: Row, key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey> | undefined;
-    merge(table: string, row: Row | Rows): Promise<IDBValidKey> | Promise<any[]> | undefined;
-    delete(table: string, key: IDBValidKey | IDBKeyRange): Promise<any[]> | undefined;
-    truncate(table: string): Promise<undefined> | undefined;
-    static connect(database: string, version: number | undefined, initialize: (driver: Driver) => void): Promise<Driver>;
-}

package/lib/driver.js

@@ -1,59 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import Database from "./database";
-export default class Driver extends Database {
-    insert(table, data) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.insert(data);
-    }
-    query(table, query, count = 1000) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.query(query, count);
-    }
-    select(table, key, index, count = 1000) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.select(key, count, index);
-    }
-    selectByKey(table, key) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.queryByKey(key);
-    }
-    count(table, key) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.count(key);
-    }
-    update(table, modify, key, count) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.update(modify, key, count);
-    }
-    merge(table, row) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.merge(row);
-    }
-    delete(table, key) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.delete(key);
-    }
-    truncate(table) {
-        var _a;
-        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.clear();
-    }
-    static connect(database_1) {
-        return __awaiter(this, arguments, void 0, function* (database, version = 1, initialize) {
-            const driver = new Driver(database, version);
-            driver.on('change', () => {
-                initialize(driver);
-            });
-            yield driver.connect();
-            return driver;
-        });
-    }
-    ;
-}