xdriver 2.0.0 → 2.0.2

package/lib/com.js

@@ -17,13 +17,6 @@ export function _copy(src, target) {
     }
     return target;
 }
-var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["debug"] = 0] = "debug";
-    LogLevel[LogLevel["warn"] = 1] = "warn";
-    LogLevel[LogLevel["info"] = 2] = "info";
-    LogLevel[LogLevel["error"] = 3] = "error";
-})(LogLevel || (LogLevel = {}));
 export class Logger {
     constructor(catalog) {
         this.catalog = catalog;
@@ -40,19 +33,19 @@ export class Logger {
         return `[${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}.${date.getMilliseconds()}]`;
     }
     debug(msg, ...args) {
-        this.print(console.debug, `%c${this.getFormatDate()} [DEBUG] <${this.catalog}> ${msg}`, ...args, "color: gray;");
+        this.print(console.debug, `%c${this.getFormatDate()} [DEBUG] <${this.catalog}> ${msg}`, "color: gray;", ...args);
     }
     warn(msg, ...args) {
-        this.print(console.warn, `%c${this.getFormatDate()} [WARN] <${this.catalog}> ${msg}`, ...args, "color: #FFCC00;");
+        this.print(console.warn, `%c${this.getFormatDate()} [WARN] <${this.catalog}> ${msg}`, "color: #FFCC00;", ...args);
     }
     info(msg, ...args) {
         this.print(console.info, `${this.getFormatDate()} [INFO] <${this.catalog}> ${msg}`, ...args);
     }
     error(msg, ...args) {
-        this.print(console.error, `%c${this.getFormatDate()} [ERROR] <${this.catalog}> ${msg}`, ...args, "color: #EF4444;");
+        this.print(console.error, `%c${this.getFormatDate()} [ERROR] <${this.catalog}> ${msg}`, "color: #EF4444;", ...args);
     }
     success(msg, ...args) {
-        this.print(console.log, `%c${this.getFormatDate()} [SUCCESS] <${this.catalog}> ${msg}`, ...args, "color: #10B981;");
+        this.print(console.log, `%c${this.getFormatDate()} [SUCCESS] <${this.catalog}> ${msg}`, "color: #10B981;", ...args);
     }
     static getLogger(catalog = 'default') {
         return new Logger(catalog);

package/lib/connection.d.ts

@@ -0,0 +1,37 @@
+import { IndexdbStatus } from "./const";
+import Table, { ITable, TableMeta } from "./table";
+interface EventMap {
+    process: (this: Connection, status: IndexdbStatus) => void;
+    success: (this: Connection, connect: IDBDatabase) => void;
+    blocked: (this: Connection, event: IDBVersionChangeEvent) => void;
+    change: (connect: IDBDatabase, event: IDBVersionChangeEvent) => void;
+    error: (evt: Event) => void;
+    close: () => void;
+}
+type EventKey = keyof EventMap;
+export default class Connection {
+    name: string;
+    version: number;
+    idbDatabase?: IDBDatabase;
+    readonly tableMap: Map<string, Table>;
+    private eventMap;
+    constructor(database?: string, version?: number);
+    on<T extends EventKey>(event: T, handle: EventMap[T]): this;
+    get connected(): boolean;
+    connect(name?: string, version?: number, upgrade?: (idbDatabase: IDBDatabase, event: IDBVersionChangeEvent) => any): Promise<any>;
+    drop(): Promise<Event>;
+    close(): void;
+    createTable(tableName: string, meta?: Omit<TableMeta, 'name'> & {
+        overwrite?: boolean;
+    }, idbDatabase?: IDBDatabase): Promise<Table>;
+    createTables(tables: Array<string | (TableMeta & {
+        overwrite?: boolean;
+    })>, meta: (Omit<ITable, "name"> & {
+        overwrite?: boolean;
+    }) | undefined, idbDatabase: IDBDatabase): Promise<Table[]>;
+    dropTable(tableName: string): boolean;
+    table(tableName: string): Table;
+    exists(table: string): boolean;
+    getTables(): Table[];
+}
+export {};

package/lib/connection.js

@@ -0,0 +1,190 @@
+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 { IndexdbStatus, innerDB } from "./const";
+import Table from "./table";
+import { Logger } from './com';
+const logger = Logger.getLogger('Database');
+export default class Connection {
+    constructor(database = 'default', version = 1) {
+        this.eventMap = {};
+        this.name = database;
+        this.version = version;
+        this.tableMap = new Map();
+    }
+    on(event, handle) {
+        this.eventMap[event] = handle;
+        return this;
+    }
+    get connected() {
+        return this.idbDatabase != void 0;
+    }
+    connect(name, version, upgrade) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((!name || version == void 0) && this.connected) {
+                return Promise.resolve(this);
+            }
+            this.name = name || this.name;
+            this.version = version || this.version;
+            logger.debug(`Connect to database ${this.name} ${this.version}`);
+            const request = innerDB.open(this.name, version);
+            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_ING);
+            request.onblocked = (evt) => {
+                var _a, _b;
+                logger.warn(`onblocked change from ${evt.oldVersion} to ${evt.newVersion}`, evt);
+                (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_CLOSE);
+                (_b = this.eventMap.blocked) === null || _b === void 0 ? void 0 : _b.call(this, evt);
+            };
+            let returnVal = void 0;
+            request.onupgradeneeded = (event) => {
+                var _a, _b;
+                logger.info(`Version change from <${event.oldVersion}> to <${event.newVersion}>`, event);
+                (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.VERSION_CHANGE);
+                const target = event.target;
+                this.idbDatabase = target.result;
+                (_b = this.eventMap.change) === null || _b === void 0 ? void 0 : _b.call(this, this.idbDatabase, event);
+                returnVal = upgrade === null || upgrade === void 0 ? void 0 : upgrade(this.idbDatabase, event);
+            };
+            return new Promise((resolve, reject) => {
+                request.onerror = (e) => {
+                    var _a, _b;
+                    logger.error('onerror', e);
+                    (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_ERROR);
+                    (_b = this.eventMap.error) === null || _b === void 0 ? void 0 : _b.call(this, e);
+                    reject(e);
+                };
+                request.onsuccess = (e) => {
+                    var _a, _b;
+                    logger.debug(`Connect Success`, e);
+                    const target = e.target;
+                    let connect = target.result;
+                    this.idbDatabase = connect;
+                    let objectStoreNames = connect.objectStoreNames;
+                    if (objectStoreNames.length) {
+                        let transaction = connect.transaction(objectStoreNames);
+                        for (let i = 0; i < objectStoreNames.length; i++) {
+                            let table = objectStoreNames.item(i);
+                            if (!table)
+                                continue;
+                            let objectStore = transaction.objectStore(table);
+                            let { indexNames, keyPath: primaryKey, name, autoIncrement = true } = objectStore;
+                            let indexes = [];
+                            for (let j = 0; indexNames && j < indexNames.length; j++) {
+                                let indexName = indexNames.item(j);
+                                if (!indexName)
+                                    continue;
+                                let { keyPath, name, multiEntry, unique } = objectStore.index(indexName);
+                                indexes.push({ name, column: keyPath, unique, multiEntry });
+                            }
+                            this.tableMap.set(name, new Table({
+                                name,
+                                primaryKey: primaryKey == null ? void 0 : primaryKey,
+                                autoIncrement,
+                                indexes
+                            }, this.idbDatabase));
+                        }
+                        transaction.commit();
+                    }
+                    (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_SUCCESS);
+                    (_b = this.eventMap.success) === null || _b === void 0 ? void 0 : _b.call(this, this.idbDatabase);
+                    resolve(returnVal || this);
+                };
+            });
+        });
+    }
+    drop() {
+        return new Promise((resolve, reject) => {
+            let request = innerDB.deleteDatabase(this.name);
+            request.onerror = function (event) {
+                reject(event);
+            };
+            request.onsuccess = function (event) {
+                resolve(event);
+            };
+            this.close();
+        });
+    }
+    close() {
+        var _a, _b, _c;
+        if (this.connected) {
+            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_CLOSE);
+            (_b = this.idbDatabase) === null || _b === void 0 ? void 0 : _b.close();
+            (_c = this.eventMap.close) === null || _c === void 0 ? void 0 : _c.call(this);
+            this.idbDatabase = void 0;
+        }
+    }
+    createTable(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, meta = {}, idbDatabase) {
+            var _a, _b;
+            const { overwrite = false } = meta;
+            if (!overwrite && this.exists(tableName)) {
+                throw new Error(`Table ${tableName} is exists`);
+            }
+            const metadata = Object.assign(Object.assign({}, meta), { name: tableName });
+            let { name = '', primaryKey = 'id', autoIncrement = true, indexes = [], rows = [] } = metadata;
+            const store = (_a = (idbDatabase || this.idbDatabase)) === null || _a === void 0 ? void 0 : _a.createObjectStore(name, { keyPath: primaryKey, autoIncrement });
+            let idxes = indexes.map(({ name, column, unique, multiEntry }) => {
+                store === null || store === void 0 ? void 0 : store.createIndex(name, column, { unique, multiEntry });
+                return { name, column, unique, multiEntry };
+            });
+            (_b = metadata.rows) === null || _b === void 0 ? void 0 : _b.forEach(row => store === null || store === void 0 ? void 0 : store.add(row));
+            let table = new Table({ name, primaryKey, autoIncrement, indexes: idxes }, idbDatabase || this.idbDatabase);
+            this.tableMap.set(name, table);
+            return table;
+        });
+    }
+    createTables(tables_1) {
+        return __awaiter(this, arguments, void 0, function* (tables, meta = {}, idbDatabase) {
+            return new Promise((resolve) => {
+                const createTables = (idbDatabase) => __awaiter(this, void 0, void 0, function* () {
+                    let list = yield Promise.all(tables.map(table => {
+                        if (typeof table === 'string') {
+                            return this.createTable(table, meta, idbDatabase);
+                        }
+                        else {
+                            return this.createTable(table.name, Object.assign(Object.assign({}, meta), table), idbDatabase);
+                        }
+                    }));
+                    resolve(list);
+                });
+                if (idbDatabase) {
+                    createTables(idbDatabase);
+                }
+                else {
+                    this.connect(this.name, ++this.version, createTables);
+                }
+            });
+        });
+    }
+    dropTable(tableName) {
+        var _a;
+        if (this.exists(tableName)) {
+            (_a = this.idbDatabase) === null || _a === void 0 ? void 0 : _a.deleteObjectStore(tableName);
+            this.tableMap.delete(tableName);
+            return true;
+        }
+        logger.error(`Table ${tableName} is not exists`);
+        throw new Error(`Table ${tableName} is not exists`);
+    }
+    table(tableName) {
+        const table = this.tableMap.get(tableName);
+        if (!table) {
+            logger.error(`Table ${tableName} is not exists`);
+            throw new Error(`Table ${tableName} is not exists`);
+        }
+        return table;
+    }
+    exists(table) {
+        return this.tableMap.has(table);
+    }
+    getTables() {
+        return [...this.tableMap.values()];
+    }
+}

package/lib/const.d.ts

@@ -9,13 +9,13 @@ export declare enum IndexdbStatus {
     VERSION_CHANGE = 99
 }
 export declare class KeyRange {
-    static leq(x: any): IDBKeyRange;
-    static lt(x: any): IDBKeyRange;
-    static geq(x: any): IDBKeyRange;
-    static gt(x: any): IDBKeyRange;
-    static between(x: any, y: any): IDBKeyRange;
-    static gt_lt(x: any, y: any): IDBKeyRange;
-    static gt_leq(x: any, y: any): IDBKeyRange;
-    static geq_lt(x: any, y: any): IDBKeyRange;
-    static eq(x: any, y: any): IDBKeyRange;
+    static leq(val: any): IDBKeyRange;
+    static lt(val: any): IDBKeyRange;
+    static geq(val: any): IDBKeyRange;
+    static gt(val: any): IDBKeyRange;
+    static between(low: any, upper: any): IDBKeyRange;
+    static gt_lt(low: any, upper: any): IDBKeyRange;
+    static gt_leq(low: any, upper: any): IDBKeyRange;
+    static geq_lt(low: any, upper: any): IDBKeyRange;
+    static eq(val: any): IDBKeyRange;
 }

package/lib/const.js

@@ -11,31 +11,31 @@ export var IndexdbStatus;
     IndexdbStatus[IndexdbStatus["VERSION_CHANGE"] = 99] = "VERSION_CHANGE";
 })(IndexdbStatus || (IndexdbStatus = {}));
 export class KeyRange {
-    static leq(x) {
-        return IDBKeyRange.upperBound(x);
+    static leq(val) {
+        return IDBKeyRange.upperBound(val);
     }
-    static lt(x) {
-        return IDBKeyRange.upperBound(x, true);
+    static lt(val) {
+        return IDBKeyRange.upperBound(val, true);
     }
-    static geq(x) {
-        return IDBKeyRange.lowerBound(x);
+    static geq(val) {
+        return IDBKeyRange.lowerBound(val);
     }
-    static gt(x) {
-        return IDBKeyRange.lowerBound(x, true);
+    static gt(val) {
+        return IDBKeyRange.lowerBound(val, true);
     }
-    static between(x, y) {
-        return IDBKeyRange.bound(x, y);
+    static between(low, upper) {
+        return IDBKeyRange.bound(low, upper);
     }
-    static gt_lt(x, y) {
-        return IDBKeyRange.bound(x, y, true, true);
+    static gt_lt(low, upper) {
+        return IDBKeyRange.bound(low, upper, true, true);
     }
-    static gt_leq(x, y) {
-        return IDBKeyRange.bound(x, y, true, false);
+    static gt_leq(low, upper) {
+        return IDBKeyRange.bound(low, upper, true, false);
     }
-    static geq_lt(x, y) {
-        return IDBKeyRange.bound(x, y, false, true);
+    static geq_lt(low, upper) {
+        return IDBKeyRange.bound(low, upper, false, true);
     }
-    static eq(x, y) {
-        return IDBKeyRange.only(x);
+    static eq(val) {
+        return IDBKeyRange.only(val);
     }
 }

package/lib/database.d.ts

@@ -1,31 +1,18 @@
-import { IndexdbStatus } from "./const";
-import Table, { Metadata } from "./table";
-interface EventMap {
-    process: (this: Database, status: IndexdbStatus) => void;
-    success: (this: Database, connect: IDBDatabase) => void;
-    blocked: (this: Database, event: IDBVersionChangeEvent) => void;
-    change: (connect: any) => void;
-    error: (evt: Event) => void;
-    close: () => void;
+import Connection from "./connection";
+import { Row, Pagination, RowPacket } from "./table";
+export default class Database extends Connection {
+    query<R extends Row>(table: string, query?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>>;
+    select<R extends Row>(table: string, key?: IDBValidKey | IDBKeyRange, index?: string, count?: number): Promise<RowPacket<R>>;
+    queryByKey<R extends Row>(table: string, key: IDBValidKey | IDBKeyRange): Promise<RowPacket<R>>;
+    queryByIndex<R extends Row>(table: string, indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>>;
+    queryById<R extends Row>(table: string, id: any | Array<any>, indexName?: string): Promise<R>;
+    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<any[]>;
+    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>>;
+    getAllData<R extends Row>(table: string): Promise<Array<R>>;
+    paginate<R extends Row>(table: string, pageNo?: number, pageSize?: number, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>>;
 }
-type EventKey = keyof EventMap;
-export default class Database {
-    private name;
-    private version;
-    database?: IDBDatabase;
-    readonly tableMap: Map<string, Table>;
-    private eventMap;
-    constructor(database: string, version?: number);
-    on<T extends EventKey>(event: T, handle: EventMap[T]): this;
-    get connected(): boolean;
-    connect(name?: string, version?: number): Promise<Database>;
-    drop(): Promise<unknown>;
-    close(): void;
-    createTable(tableName: string, meta?: Omit<Metadata, 'name'>): Table;
-    createTables(tables: Array<string>, meta?: Omit<Metadata, 'name' | 'rows'>): Table[];
-    dropTable(tableName: string): boolean;
-    table(tableName: string): Table | undefined;
-    exists(table: string): boolean;
-    getTables(): MapIterator<Table>;
-}
-export {};

package/lib/database.js

@@ -1,146 +1,62 @@
-import { IndexdbStatus, innerDB } from "./const";
-import Table from "./table";
-import { Logger } from './com';
-const logger = Logger.getLogger('Database');
-export default class Database {
-    constructor(database, version = 1) {
-        this.eventMap = {};
-        this.name = database;
-        this.version = version;
-        this.tableMap = new Map();
-    }
-    on(event, handle) {
-        this.eventMap[event] = handle;
-        return this;
-    }
-    get connected() {
-        return this.database != void 0;
-    }
-    connect(name, version) {
-        var _a;
-        if (!name && version == void 0 && this.connected) {
-            return Promise.resolve(this);
-        }
-        this.name = name || this.name;
-        this.version = version || this.version;
-        const request = innerDB.open(this.name, version);
-        (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_ING);
-        request.onerror = (e) => {
-            var _a, _b;
-            logger.error('onerror', e);
-            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_ERROR);
-            (_b = this.eventMap.error) === null || _b === void 0 ? void 0 : _b.call(this, e);
-        };
-        request.onblocked = (evt) => {
-            var _a, _b;
-            logger.warn(`onblocked change from ${evt.oldVersion} to ${evt.newVersion}`, evt);
-            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_CLOSE);
-            (_b = this.eventMap.blocked) === null || _b === void 0 ? void 0 : _b.call(this, evt);
-        };
-        return new Promise((resolve, reject) => {
-            request.onupgradeneeded = (event) => {
-                var _a, _b;
-                logger.info(`Version change from <${event.oldVersion}> to <${event.newVersion}>`, event);
-                (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.VERSION_CHANGE);
-                const target = event.target;
-                this.database = target.result;
-                (_b = this.eventMap.change) === null || _b === void 0 ? void 0 : _b.call(this, this.database);
-            };
-            request.onsuccess = (e) => {
-                var _a, _b;
-                logger.info(`Connect Success`, e);
-                const target = e.target;
-                let connect = target.result;
-                this.database = connect;
-                let objectStoreNames = connect.objectStoreNames;
-                if (objectStoreNames.length) {
-                    let transaction = connect.transaction(objectStoreNames);
-                    for (let i = 0; i < objectStoreNames.length; i++) {
-                        let table = objectStoreNames.item(i);
-                        if (!table)
-                            continue;
-                        let objectStore = transaction.objectStore(table);
-                        let { indexNames, keyPath: primaryKey, name, autoIncrement = true } = objectStore;
-                        let indexes = [];
-                        for (let j = 0; indexNames && j < indexNames.length; j++) {
-                            let indexName = indexNames.item(j);
-                            if (!indexName)
-                                continue;
-                            let { keyPath, name, multiEntry, unique } = objectStore.index(indexName);
-                            indexes.push({ name, column: keyPath, unique, multiEntry });
-                        }
-                        this.tableMap.set(name, new Table({ name, primaryKey: primaryKey == null ? void 0 : primaryKey, autoIncrement, indexes }, this.database));
-                    }
-                }
-                (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_SUCCESS);
-                (_b = this.eventMap.success) === null || _b === void 0 ? void 0 : _b.call(this, this.database);
-                resolve(this);
-            };
+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 Connection from "./connection";
+export default class Database extends Connection {
+    query(table, query, count = 1000) {
+        return this.table(table).query(query, count);
+    }
+    select(table, key, index, count = 1000) {
+        return this.table(table).select(key, count, index);
+    }
+    queryByKey(table, key) {
+        return this.table(table).queryByKey(key);
+    }
+    queryByIndex(table, indexName, key, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.table(table).queryByIndex(indexName, key, count);
         });
     }
-    drop() {
-        return new Promise((resolve, reject) => {
-            let request = innerDB.deleteDatabase(this.name);
-            request.onerror = function (event) {
-                reject(event);
-            };
-            request.onsuccess = function (event) {
-                resolve(event);
-            };
-            this.close();
+    queryById(table, id, indexName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.table(table).queryById(id, indexName);
         });
     }
-    close() {
-        var _a, _b, _c;
-        if (this.connected) {
-            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_CLOSE);
-            (_b = this.database) === null || _b === void 0 ? void 0 : _b.close();
-            (_c = this.eventMap.close) === null || _c === void 0 ? void 0 : _c.call(this);
-            this.database = void 0;
-        }
+    count(table, key) {
+        return this.table(table).count(key);
     }
-    createTable(tableName, meta = {}) {
-        var _a, _b;
-        if (this.exists(tableName)) {
-            throw new Error(`Table ${tableName} is exists`);
-        }
-        const metadata = Object.assign(Object.assign({}, meta), { name: tableName });
-        let { name = '', primaryKey = 'id', autoIncrement = true, indexes = [], rows = [] } = metadata;
-        const store = (_a = this.database) === null || _a === void 0 ? void 0 : _a.createObjectStore(name, { keyPath: primaryKey, autoIncrement });
-        let idxes = indexes.map(({ name, column, unique, multiEntry }) => {
-            store === null || store === void 0 ? void 0 : store.createIndex(name, column, { unique, multiEntry });
-            return { name, column, unique, multiEntry };
-        });
-        (_b = metadata.rows) === null || _b === void 0 ? void 0 : _b.forEach(row => store === null || store === void 0 ? void 0 : store.add(row));
-        let tab = new Table({ name, primaryKey, autoIncrement, indexes: idxes }, this.database);
-        this.tableMap.set(name, tab);
-        return tab;
+    insert(table, data) {
+        return this.table(table).insert(data);
     }
-    createTables(tables, meta = {}) {
-        return tables.map(table => {
-            return this.createTable(table, meta);
-        });
+    update(table, modify, key) {
+        return this.table(table).update(modify, key);
     }
-    dropTable(tableName) {
-        var _a;
-        if (this.exists(tableName)) {
-            (_a = this.database) === null || _a === void 0 ? void 0 : _a.deleteObjectStore(tableName);
-            this.tableMap.delete(tableName);
-            return true;
-        }
-        return false;
+    delete(table, key) {
+        return this.table(table).delete(key);
     }
-    table(tableName) {
-        const table = this.tableMap.get(tableName);
-        if (!table) {
-            logger.error(`Table ${tableName} is not exists`);
-        }
-        return table;
+    truncate(table) {
+        return this.table(table).truncate();
     }
-    exists(table) {
-        return this.tableMap.has(table);
+    getPagination(table, pageSize = 10) {
+        return this.table(table).getPagination(pageSize, 1);
     }
-    getTables() {
-        return this.tableMap.values();
+    scan(table_1, key_1) {
+        return __awaiter(this, arguments, void 0, function* (table, key, direction = 'next', indexName) {
+            return this.table(table).scan(key, direction, indexName);
+        });
+    }
+    getAllData(table) {
+        return this.table(table).getAllData();
+    }
+    paginate(table_1) {
+        return __awaiter(this, arguments, void 0, function* (table, pageNo = 1, pageSize = 10, key, indexName) {
+            return this.table(table).paginate(pageNo, pageSize, key, indexName);
+        });
     }
 }

package/lib/index.d.ts

@@ -1,6 +1,15 @@
 import { IndexdbStatus, KeyRange } from "./const";
-import Driver from "./driver";
 import Database from "./database";
-import Table from "./table";
-export { IndexdbStatus, KeyRange, Database, Table, Driver };
+import Connection from "./connection";
+import Table, { TableMeta } from "./table";
+export { IndexdbStatus, KeyRange, Connection, Table };
+declare class Driver {
+    private readonly name;
+    private version;
+    private readonly tables;
+    constructor(name: string, version?: number);
+    defineTables(...tables: Array<TableMeta>): this;
+    private hasChange;
+    connect(version?: number): Promise<Database>;
+}
 export default Driver;

package/lib/index.js

@@ -1,6 +1,140 @@
-import { IndexdbStatus, KeyRange } from "./const";
-import Driver from "./driver";
+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 { IndexdbStatus, innerDB, KeyRange } from "./const";
 import Database from "./database";
+import Connection from "./connection";
 import Table from "./table";
-export { IndexdbStatus, KeyRange, Database, Table, Driver };
+import { Logger } from "./com";
+export { IndexdbStatus, KeyRange, Connection, Table };
+const logger = Logger.getLogger("Driver");
+class Driver {
+    constructor(name, version = 0) {
+        this.tables = [];
+        this.name = name;
+        this.version = version;
+    }
+    defineTables(...tables) {
+        this.tables.push(...tables);
+        logger.debug(`Define tables: ${tables.map(t => t.name).join(', ')}`);
+        return this;
+    }
+    hasChange(database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const existTables = database.getTables();
+            const defineTables = this.tables;
+            if (existTables.length !== defineTables.length) {
+                logger.warn(`Table count is changed.`);
+                return true;
+            }
+            let change = false;
+            for (let table of defineTables) {
+                if (!existTables.some(t => t.name === table.name)) {
+                    logger.warn(`Table ${table.name} is added, create it.`);
+                    change = true;
+                    break;
+                }
+            }
+            if (change) {
+                return change;
+            }
+            for (let existTable of existTables) {
+                const tableMeta = defineTables.find(t => t.name === existTable.name);
+                if (!tableMeta) {
+                    logger.warn(`Table ${existTable.name} is removed, drop it.`);
+                    change = true;
+                    break;
+                }
+                let existIndexes = existTable.indexes || [];
+                for (let existIndex of existIndexes) {
+                    const metaIndex = (_a = tableMeta.indexes) === null || _a === void 0 ? void 0 : _a.find(i => i.name === existIndex.name);
+                    if (!metaIndex) {
+                        logger.warn(`Table ${existTable.name} index ${existIndex.name} is removed, drop it.`);
+                        change = true;
+                        break;
+                    }
+                }
+                if (change) {
+                    break;
+                }
+                for (let metaIndex of tableMeta.indexes || []) {
+                    const index = existIndexes.find(i => i.name === metaIndex.name);
+                    if (!index) {
+                        logger.warn(`Table ${existTable.name} index ${metaIndex.name} is added, create it.`);
+                        change = true;
+                        break;
+                    }
+                }
+                if (change) {
+                    break;
+                }
+            }
+            return change;
+        });
+    }
+    connect(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const databases = yield innerDB.databases();
+            const existsDB = databases.find(db => db.name === this.name);
+            if (existsDB) {
+                logger.info(`Database ${this.name} exists`);
+                this.version = existsDB.version || this.version;
+            }
+            if (version) {
+                this.version = Math.max(this.version, version);
+            }
+            logger.debug(`Connect to database ${this.name} ${this.version}`);
+            const database = new Database(this.name, this.version);
+            database.on('change', (idbDatabase, event) => {
+                const existTables = [...idbDatabase.objectStoreNames];
+                if (existTables.length) {
+                    for (let tableName of existTables) {
+                        let existTable = this.tables.find(t => t.name === tableName);
+                        if (!existTable) {
+                            logger.warn(`Table ${tableName} is removed, drop it.`);
+                            database.dropTable(tableName);
+                            continue;
+                        }
+                        const transaction = event.target.transaction;
+                        if (!transaction) {
+                            logger.warn(`Transaction not support`);
+                            continue;
+                        }
+                        let objectStore = transaction.objectStore(tableName);
+                        if (!objectStore) {
+                            logger.warn(`Table ${tableName} not exists`);
+                            continue;
+                        }
+                        let { indexNames } = objectStore;
+                        for (let indexName of indexNames) {
+                            objectStore.deleteIndex(indexName);
+                        }
+                        for (let index of existTable.indexes || []) {
+                            objectStore.createIndex(index.name, index.column, Object.assign({}, index));
+                        }
+                    }
+                }
+                for (let table of this.tables) {
+                    if (existTables.indexOf(table.name) < 0) {
+                        logger.info(`Table ${table.name} is not exist, create it.`);
+                        database.createTable(table.name, table);
+                    }
+                }
+            });
+            yield database.connect();
+            if (yield this.hasChange(database)) {
+                database.close();
+                yield database.connect(this.name, ++this.version);
+            }
+            return database;
+        });
+    }
+}
 export default Driver;

package/lib/table.d.ts

@@ -12,9 +12,43 @@ export type ITable = {
 };
 export type Row = Record<string, any>;
 export type Rows = Array<Row>;
-export type Metadata = ITable & {
+export type TableMeta = ITable & {
     rows?: Rows;
 };
+export declare class RowPacket<T extends Row> extends Array<T> {
+    constructor(rows?: Array<T>);
+    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>;
+    group<K, V>(key: keyof T | ((row: T, index: number, array: Array<T>) => K)): Map<K, Array<T>>;
+    group<K, V>(key: keyof T | ((row: T, index: number, array: Array<T>) => K), valFn: (row: T, index: number, array: Array<T>) => V): Map<K, Array<V>>;
+    max(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): {
+        value: number;
+        rows: Array<T>;
+    };
+    min(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): {
+        value: number;
+        rows: Array<T>;
+    };
+    sum(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): number;
+    average(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): number;
+}
+export declare class Pagination<T extends Row> {
+    private readonly _data;
+    private readonly _pageSize;
+    private _pageIndex;
+    private readonly _total;
+    constructor(data: Array<T>, pageSize?: number, pageIndex?: number);
+    get totalPage(): number;
+    get total(): number;
+    get pageIndex(): number;
+    get pageSize(): number;
+    get hasNext(): boolean;
+    get hasPrev(): boolean;
+    get data(): Array<any>;
+    prev(): boolean;
+    next(): boolean;
+}
 export default class Table implements ITable {
     readonly name: string;
     readonly primaryKey: string | string[];
@@ -22,19 +56,21 @@ export default class Table implements ITable {
     readonly indexes: Array<Index>;
     readonly database?: IDBDatabase;
     constructor(table: ITable | string, database?: IDBDatabase);
-    insert(data: Row | Rows): Promise<any[]>;
-    update(modify: Row, key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey>;
-    merge(row: Row): Promise<IDBValidKey> | Promise<any[]>;
+    get meta(): TableMeta;
+    insert(data: Row | Rows): Promise<Array<IDBValidKey>>;
+    update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey>;
     delete(key: IDBValidKey | IDBKeyRange): Promise<any[]>;
-    clear(): Promise<undefined>;
+    truncate(): Promise<void>;
     dropIndex(name: string): void;
     keys(key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey[]>;
     count(key?: IDBValidKey | IDBKeyRange): Promise<number>;
-    query(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<Rows>;
-    select(key?: IDBValidKey | IDBKeyRange, count?: number, index?: string): Promise<Rows>;
-    queryByKey(key: IDBValidKey | IDBKeyRange): Promise<Row>;
-    fetch(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): Promise<Rows>;
-    queryByIndex(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<Rows>;
-    deplete(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): Promise<Rows>;
-    multiple(indexName: string, key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): Promise<Rows>;
+    query<R extends Row>(key?: IDBValidKey | IDBKeyRange, count?: number): 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>>;
+    paginate<R extends Row>(pageNo?: number, pageSize?: number, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>>;
+    queryById<R extends Row>(id: any | Array<any>, indexName?: string): Promise<R>;
+    scan<R extends Row>(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection, indexName?: string): Promise<RowPacket<R>>;
+    getAllData<R extends Row>(): Promise<Array<R>>;
+    getPagination<R extends Row>(pageSize?: number, pageIndex?: number): Promise<Pagination<R>>;
 }

package/lib/table.js

@@ -7,15 +7,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { _copy, _instance } from "./com";
+import { Logger } from "./com";
+const logger = Logger.getLogger('Table');
 const _getObjectStore = (table, mode = 'readonly') => {
     var _a;
     const trans = (_a = table.database) === null || _a === void 0 ? void 0 : _a.transaction(table.name, mode);
     if (!trans) {
         throw new Error('database not open');
     }
-    trans.oncomplete = (e) => console.debug(e);
-    trans.onerror = (e) => console.debug(e);
+    trans.oncomplete = (event) => {
+        logger.debug(`Table ${table.name} transaction success`, event);
+    };
+    trans.onerror = (event) => {
+        logger.error(`Table ${table.name} transaction error`, event);
+    };
     return trans.objectStore(table.name);
 };
 const _request = (request) => __awaiter(void 0, void 0, void 0, function* () {
@@ -28,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;
@@ -49,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');
@@ -61,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) {
@@ -100,7 +235,7 @@ export default class Table {
             return rows;
         });
     }
-    clear() {
+    truncate() {
         return _request(_getObjectStore(this, 'readwrite').clear());
     }
     dropIndex(name) {
@@ -113,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.0",
+  "version": "2.0.2",
   "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;
-        });
-    }
-    ;
-}