xdriver 2.0.12 → 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

@@ -15,8 +15,20 @@ export type Rows = Array<Row>;
 export type TableMeta = ITable & {
     rows?: Rows;
 };
-export declare class RowPacket<T extends Row> extends Array<T> {
+export declare class RowPacket<T extends Row> {
+    private readonly rows;
     constructor(rows?: Array<T>);
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    forEach(callback: (value: T, index: number, array: Array<T>) => void): void;
+    filter(callback: (value: T, index: number, array: Array<T>) => boolean): Array<T>;
+    reduce<U>(callback: (previousValue: U, currentValue: T, currentIndex: number, array: Array<T>) => U, initialValue: U): U;
+    map<U>(callback: (value: T, index: number, array: Array<T>) => U): Array<U>;
+    some(callback: (value: T, index: number, array: Array<T>) => boolean): boolean;
+    find(callback: (value: T, index: number, array: Array<T>) => boolean): T | undefined;
+    push(...items: Array<T>): void;
+    slice(start?: number, end?: number): Array<T>;
+    join(separator?: string): string;
+    get length(): number;
     distinct(column?: string | ((row: T) => any)): Array<T>;
     mapping<K, T>(keyFn: (row: T, index: number, array: Array<T>) => K): Map<K, T>;
     mapping<K, V>(keyFn: (row: T, index: number, array: Array<T>) => K, valFn: (row: T, index: number, array: Array<T>) => V): Map<K, V>;
@@ -57,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

@@ -33,13 +33,48 @@ const _request = (request) => __awaiter(void 0, void 0, void 0, function* () {
         };
     });
 });
-export class RowPacket extends Array {
+export class RowPacket {
     constructor(rows = []) {
-        super(...rows);
+        this.rows = rows;
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.rows) {
+            yield item;
+        }
+    }
+    forEach(callback) {
+        this.rows.forEach(callback);
+    }
+    filter(callback) {
+        return this.rows.filter(callback);
+    }
+    reduce(callback, initialValue) {
+        return this.rows.reduce(callback, initialValue);
+    }
+    map(callback) {
+        return this.rows.map(callback);
+    }
+    some(callback) {
+        return this.rows.some(callback);
+    }
+    find(callback) {
+        return this.rows.find(callback);
+    }
+    push(...items) {
+        this.rows.push(...items);
+    }
+    slice(start, end) {
+        return this.rows.slice(start, end);
+    }
+    join(separator) {
+        return this.rows.join(separator);
+    }
+    get length() {
+        return this.rows.length;
     }
     distinct(column) {
         if (!column) {
-            return this;
+            return this.rows;
         }
         let set = new Set();
         return this.filter(row => {
@@ -77,7 +112,7 @@ export class RowPacket extends Array {
         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;
+            let value = valFn ? valFn(item, index, this.rows) : item;
             if (!group.has(unionKey)) {
                 group.set(unionKey, [value]);
             }
@@ -218,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() {
@@ -247,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.12",
+  "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

@@ -49,10 +49,56 @@ export type Rows = Array<Row>;
 
 export type TableMeta = ITable & { rows?: Rows };
 
-export class RowPacket<T extends Row> extends Array<T> {
+export class RowPacket<T extends Row> {
+
+    private readonly rows: Array<T>;
 
     constructor(rows: Array<T> = []) {
-        super(...rows)
+        this.rows = rows;
+    }
+
+    *[Symbol.iterator]() {
+        // 使用 generator 函数最简单！
+        for (const item of this.rows) {
+            yield item;
+        }
+    }
+
+    forEach(callback: (value: T, index: number, array: Array<T>) => void) {
+        this.rows.forEach(callback);
+    }
+
+    filter(callback: (value: T, index: number, array: Array<T>) => boolean): Array<T> {
+        return this.rows.filter(callback);
+    }
+
+    reduce<U>(callback: (previousValue: U, currentValue: T, currentIndex: number, array: Array<T>) => U,
+                       initialValue: U): U {
+        return this.rows.reduce(callback, initialValue);
+    }
+
+    map<U>(callback: (value: T, index: number, array: Array<T>) => U): Array<U> {
+        return this.rows.map(callback);
+    }
+
+    some(callback: (value: T, index: number, array: Array<T>) => boolean): boolean {
+        return this.rows.some(callback);
+    }
+    find(callback: (value: T, index: number, array: Array<T>) => boolean): T | undefined {
+        return this.rows.find(callback);
+    }
+    push(...items: Array<T>) {
+        this.rows.push(...items);
+    }
+    slice(start?: number, end?: number): Array<T> {
+        return this.rows.slice(start, end);
+    }
+    join(separator?: string): string {
+        return this.rows.join(separator);
+    }
+
+    get length(): number {
+        return this.rows.length;
     }
 
     /**
@@ -61,7 +107,7 @@ export class RowPacket<T extends Row> extends Array<T> {
      */
     distinct(column?: string | ((row: T) => any)): Array<T> {
         if (!column) {
-            return this;
+            return this.rows;
         }
         let set = new Set<any>();
         return this.filter(row => {
@@ -111,7 +157,7 @@ export class RowPacket<T extends Row> extends Array<T> {
         let group = new Map<K, Array<V | T>>();
         this.forEach((item, index, array) => {
             let unionKey: K = typeof key === 'function' ? key.call(this, item, index, array) : item[key];
-            let value = valFn ? valFn(item, index, this) : item;
+            let value = valFn ? valFn(item, index, this.rows) : item;
             if (!group.has(unionKey)) {
                 group.set(unionKey, [value]);
             } else {
@@ -346,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;
     }
 
     /**
@@ -402,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 索引名称
@@ -473,7 +539,7 @@ export default class Table implements ITable{
      * @param direction
      * @param indexName
      */
-    async scan<R extends Row>(key?: IDBValidKey | IDBKeyRange, direction: IDBCursorDirection = 'next', indexName?: string): Promise<RowPacket<R>> {
+    async scan<R extends Row>(key?:  IDBValidKey | IDBKeyRange, direction: IDBCursorDirection = 'next', indexName?: string): Promise<RowPacket<R>> {
         const store = _getObjectStore(this)
         let request: IDBRequest<IDBCursorWithValue | null>
         if (!indexName) {