xdriver 2.0.13 → 2.0.15

package/lib/database.d.ts

@@ -10,7 +10,7 @@ export default class Database extends Connection {
     count(table: string, key: IDBValidKey | IDBKeyRange): Promise<number>;
     insert(table: string, data: Array<Record<string, any>>): Promise<IDBValidKey[]>;
     update(table: string, modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey>;
-    delete(table: string, key: IDBValidKey | IDBKeyRange): Promise<Row[]>;
+    delete(table: string, key: IDBValidKey | IDBKeyRange): Promise<void>;
     truncate(table: string): Promise<void>;
     getPagination<R extends Row>(table: string, pageSize?: number): Promise<Pagination<R>>;
     scan<R extends Row>(table: string, key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection, indexName?: string): Promise<RowPacket<R>>;

package/lib/mapper.d.ts

@@ -1,16 +1,19 @@
 import Table, { Pagination, Row, RowPacket } from "./table";
 export default class Mapper<T extends Row> {
-    private table;
+    private _table;
     constructor(table: Table);
+    get table(): Table;
     truncate(): Promise<void>;
     count(key?: IDBValidKey | IDBKeyRange): Promise<number>;
     insert(data: T | Array<T>): Promise<IDBValidKey[]>;
     update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey>;
     query(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>>;
     queryById(id: any | Array<any>, indexName?: string): Promise<T | Array<T>>;
-    delete(key: IDBValidKey | IDBKeyRange): Promise<Array<T>>;
+    deleteByKeys(...keys: IDBValidKey[]): Promise<void>;
+    delete(key: IDBValidKey | IDBKeyRange): Promise<void>;
     queryByIndex(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>>;
     queryByKey(key: IDBValidKey | IDBKeyRange): Promise<RowPacket<T>>;
+    queryByKeys<R extends Row>(keys: IDBValidKey[]): Promise<RowPacket<R>>;
     scan(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection, indexName?: string): Promise<RowPacket<T>>;
     select(key?: IDBValidKey | IDBKeyRange, count?: number, indexName?: string): Promise<RowPacket<T>>;
     paginate<R extends Row>(pageNo?: number, pageSize?: number, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>>;

package/lib/mapper.js

@@ -1,47 +1,67 @@
+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());
+    });
+};
 export default class Mapper {
     constructor(table) {
-        this.table = table;
+        this._table = table;
+    }
+    get table() {
+        return this._table;
     }
     truncate() {
-        return this.table.truncate();
+        return this._table.truncate();
     }
     count(key) {
-        return this.table.count(key);
+        return this._table.count(key);
     }
     insert(data) {
-        return this.table.insert(data);
+        return this._table.insert(data);
     }
     update(modify, key) {
-        return this.table.update(modify, key);
+        return this._table.update(modify, key);
     }
     query(key, count) {
-        return this.table.query(key, count);
+        return this._table.query(key, count);
     }
     queryById(id, indexName) {
-        return this.table.queryById(id, indexName);
+        return this._table.queryById(id, indexName);
+    }
+    deleteByKeys(...keys) {
+        return this._table.deleteByKeys(...keys);
     }
     delete(key) {
-        return this.table.delete(key);
+        return this._table.delete(key);
     }
     queryByIndex(indexName, key, count) {
-        return this.table.queryByIndex(indexName, key, count);
+        return this._table.queryByIndex(indexName, key, count);
     }
     queryByKey(key) {
-        return this.table.queryByKey(key);
+        return this._table.queryByKey(key);
+    }
+    queryByKeys(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._table.queryByKeys(keys);
+        });
     }
     scan(key, direction = 'next', indexName) {
-        return this.table.scan(key, direction, indexName);
+        return this._table.scan(key, direction, indexName);
     }
     select(key, count, indexName) {
-        return this.table.select(key, count, indexName);
+        return this._table.select(key, count, indexName);
     }
     paginate(pageNo = 1, pageSize = 10, key, indexName) {
-        return this.table.paginate(pageNo, pageSize, key, indexName);
+        return this._table.paginate(pageNo, pageSize, key, indexName);
     }
     getPagination(pageSize = 10) {
-        return this.table.getPagination(pageSize);
+        return this._table.getPagination(pageSize);
     }
     getAll() {
-        return this.table.getAllData();
+        return this._table.getAllData();
     }
 }

package/lib/table.d.ts

@@ -69,12 +69,14 @@ export default class Table implements ITable {
     get meta(): TableMeta;
     insert(data: Row | Rows): Promise<Array<IDBValidKey>>;
     update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey>;
-    delete<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<Array<R>>;
+    deleteByKeys<R extends Row>(...keys: IDBValidKey[]): Promise<void>;
+    delete<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<void>;
     truncate(): Promise<void>;
     dropIndex(name: string): void;
     keys(key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey[]>;
     count(key?: IDBValidKey | IDBKeyRange): Promise<number>;
     query<R extends Row>(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>>;
+    queryByKeys<R extends Row>(keys: IDBValidKey[]): Promise<RowPacket<R>>;
     queryByIndex<R extends Row>(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>>;
     select<R extends Row>(key?: IDBValidKey | IDBKeyRange, count?: number, indexName?: string): Promise<RowPacket<R>>;
     queryByKey<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<RowPacket<R>>;

package/lib/table.js

@@ -253,15 +253,24 @@ export default class Table {
             return _request(store.put(modify, key));
         });
     }
+    deleteByKeys(...keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!keys.length) {
+                return Promise.reject('keys is required');
+            }
+            let objectStore = _getObjectStore(this, 'readwrite');
+            for (let key of keys) {
+                yield _request(objectStore.delete(key));
+            }
+        });
+    }
     delete(key) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!key) {
                 return Promise.reject('key is required');
             }
             let objectStore = _getObjectStore(this, 'readwrite');
-            let rows = yield _request(objectStore.getAll(key));
             yield _request(objectStore.delete(key));
-            return rows;
         });
     }
     truncate() {
@@ -282,6 +291,20 @@ export default class Table {
             return new RowPacket(rows);
         });
     }
+    queryByKeys(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!keys.length) {
+                return Promise.reject('keys is required');
+            }
+            let objectStore = _getObjectStore(this);
+            let rows = [];
+            for (let key of keys) {
+                let row = yield _request(objectStore.get(IDBKeyRange.only(key)));
+                rows.push(row);
+            }
+            return new RowPacket(rows);
+        });
+    }
     queryByIndex(indexName, key, count) {
         return __awaiter(this, void 0, void 0, function* () {
             const store = _getObjectStore(this);

package/package.json

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

package/src/mapper.ts

@@ -1,65 +1,77 @@
 import Table, {Pagination, Row, RowPacket} from "./table";
 
 export default class Mapper<T extends Row> {
-    private table: Table;
+    private _table: Table;
 
     constructor(table: Table) {
-        this.table = table;
+        this._table = table;
+    }
+
+    get table(): Table {
+        return this._table;
     }
 
     truncate() {
-        return this.table.truncate();
+        return this._table.truncate();
     }
 
     count(key?: IDBValidKey | IDBKeyRange) {
-        return this.table.count(key);
+        return this._table.count(key);
     }
 
     insert(data: T | Array<T>) {
-        return this.table.insert(data);
+        return this._table.insert(data);
     }
 
     update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey> {
-        return this.table.update(modify, key);
+        return this._table.update(modify, key);
     }
 
     query(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>> {
-        return this.table.query(key, count);
+        return this._table.query(key, count);
     }
 
     queryById(id: any | Array<any>, indexName?: string): Promise<T | Array<T>> {
-        return this.table.queryById(id, indexName);
+        return this._table.queryById(id, indexName);
+    }
+
+    deleteByKeys(...keys: IDBValidKey[]): Promise<void> {
+        return this._table.deleteByKeys(...keys);
     }
 
-    delete(key: IDBValidKey | IDBKeyRange): Promise<Array<T>> {
-        return this.table.delete(key);
+    delete(key: IDBValidKey | IDBKeyRange): Promise<void> {
+        return this._table.delete(key);
     }
 
     queryByIndex(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>> {
-        return this.table.queryByIndex(indexName, key, count);
+        return this._table.queryByIndex(indexName, key, count);
     }
 
     queryByKey(key: IDBValidKey | IDBKeyRange): Promise<RowPacket<T>> {
-        return this.table.queryByKey(key);
+        return this._table.queryByKey(key);
+    }
+
+    async queryByKeys<R extends Row>(keys: IDBValidKey[]): Promise<RowPacket<R>> {
+        return this._table.queryByKeys(keys);
     }
 
     scan(key?: IDBValidKey | IDBKeyRange, direction: IDBCursorDirection = 'next', indexName?: string): Promise<RowPacket<T>> {
-        return this.table.scan(key, direction, indexName);
+        return this._table.scan(key, direction, indexName);
     }
 
     select(key?: IDBValidKey | IDBKeyRange, count?: number, indexName?: string): Promise<RowPacket<T>> {
-        return this.table.select(key, count, indexName);
+        return this._table.select(key, count, indexName);
     }
 
     paginate<R extends Row>(pageNo: number = 1, pageSize: number = 10, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>> {
-        return this.table.paginate(pageNo, pageSize, key, indexName);
+        return this._table.paginate(pageNo, pageSize, key, indexName);
     }
 
     getPagination(pageSize: number = 10): Promise<Pagination<T>> {
-        return this.table.getPagination(pageSize);
+        return this._table.getPagination(pageSize);
     }
 
     getAll(): Promise<Array<T>> {
-        return this.table.getAllData();
+        return this._table.getAllData();
     }
 }

package/src/table.ts

@@ -392,18 +392,25 @@ export default class Table implements ITable{
         return _request(store.put(modify, key as IDBValidKey));
     }
 
+    async deleteByKeys<R extends Row>(...keys: IDBValidKey[]): Promise<void> {
+        if (!keys.length) {
+            return Promise.reject('keys is required');
+        }
+        let objectStore = _getObjectStore(this, 'readwrite');
+        for (let key of keys) {
+            await _request(objectStore.delete(key));
+        }
+    }
     /**
      * 根据主键值删除
      * @param key
      */
-    async delete<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<Array<R>> {
+    async delete<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<void> {
         if (!key) {
             return Promise.reject('key is required');
         }
         let objectStore = _getObjectStore(this, 'readwrite');
-        let rows = await _request(objectStore.getAll(key));
         await _request(objectStore.delete(key));
-        return rows;
     }
 
     /**
@@ -448,6 +455,19 @@ export default class Table implements ITable{
         return new RowPacket<R>(rows);
     }
 
+    async queryByKeys<R extends Row>(keys: IDBValidKey[]): Promise<RowPacket<R>> {
+        if (!keys.length) {
+            return Promise.reject('keys is required');
+        }
+        let objectStore = _getObjectStore(this);
+        let rows: Array<R> = []
+        for (let key of keys) {
+            let row = await _request(objectStore.get(IDBKeyRange.only(key)));
+            rows.push(row)
+        }
+        return new RowPacket(rows);
+    }
+
     /**
      *
      * @param indexName 索引名称