xdriver 2.0.4 → 2.0.6

package/lib/index.d.ts

@@ -2,7 +2,7 @@ import { IndexdbStatus, KeyRange } from "./const";
 import Database from "./database";
 import Connection from "./connection";
 import Table, { TableMeta } from "./table";
-export { IndexdbStatus, KeyRange, Connection, Table };
+import { Logger } from "./com";
 declare class Driver {
     private readonly name;
     private version;
@@ -12,4 +12,5 @@ declare class Driver {
     private hasChange;
     connect(version?: number): Promise<Database>;
 }
+export { IndexdbStatus, KeyRange, Connection, Table, Logger, Driver };
 export default Driver;

package/lib/index.js

@@ -12,7 +12,6 @@ import Database from "./database";
 import Connection from "./connection";
 import Table from "./table";
 import { Logger } from "./com";
-export { IndexdbStatus, KeyRange, Connection, Table };
 const logger = Logger.getLogger("Driver");
 class Driver {
     constructor(name, version = 0) {
@@ -137,4 +136,5 @@ class Driver {
         });
     }
 }
+export { IndexdbStatus, KeyRange, Connection, Table, Logger, Driver };
 export default Driver;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "xdriver",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "A simple driver for IndexDB",
   "main": "./lib/index",
   "files": [
-    "lib/"
+    "lib/", "src"
   ],
   "scripts": {
     "build": "tsc",

package/src/com.ts

@@ -0,0 +1,68 @@
+export function _instance(example: any, type: any) {
+    let pro = type.prototype;
+    example = example.__proto__;
+    while (true) {
+        if (example === null)
+            return false;
+        if (pro === example)
+            return true;
+        example = example.__proto__;
+    }
+}
+
+export function _copy(src: any, target: any) {
+    if (!target) return src;
+    for (let prop in src) {
+        target[prop] = src[prop];
+    }
+    return target;
+}
+
+export class Logger {
+    public static trace: boolean;
+    private readonly catalog: string;
+
+    constructor(catalog: string) {
+        this.catalog = catalog;
+    }
+
+    private print(fn: Function, ...args: any[]) {
+        if (Logger.trace) {
+            console.trace(...args);
+            return;
+        }
+        fn(...args);
+    }
+
+    private getFormatDate() {
+        const date = new Date();
+        return `[${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}.${date.getMilliseconds()}]`;
+    }
+
+    debug(msg: string, ...args: any[]) {
+        this.print(console.debug, `%c${this.getFormatDate()} [DEBUG] <${this.catalog}> ${msg}`, "color: gray;", ...args);
+
+    }
+
+    warn(msg: string, ...args: any[]) {
+        this.print(console.warn, `%c${this.getFormatDate()} [WARN] <${this.catalog}> ${msg}`, "color: #FFCC00;", ...args)
+    }
+
+    info(msg: string, ...args: any[]) {
+        this.print(console.info, `${this.getFormatDate()} [INFO] <${this.catalog}> ${msg}`, ...args)
+    }
+
+    error(msg: string, ...args: any[]) {
+        this.print(console.error, `%c${this.getFormatDate()} [ERROR] <${this.catalog}> ${msg}`, "color: #EF4444;", ...args)
+    }
+
+    success(msg: string, ...args: any[]) {
+        this.print(console.log, `%c${this.getFormatDate()} [SUCCESS] <${this.catalog}> ${msg}`, "color: #10B981;", ...args)
+    }
+
+    static getLogger(catalog: string = 'default') {
+        return new Logger(catalog);
+    }
+}
+
+export const logger = Logger.getLogger();

package/src/connection.ts

@@ -0,0 +1,220 @@
+import {IndexdbStatus, innerDB} from "./const";
+import Table, {Index, ITable, TableMeta} from "./table";
+import {Logger} from './com'
+
+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;
+
+const logger = Logger.getLogger('Database');
+
+export default class Connection {
+    name: string;
+    version: number;
+    public idbDatabase?: IDBDatabase; //数据库连接
+    readonly tableMap: Map<string, Table>;
+    private eventMap: Partial<EventMap> = {};
+
+    constructor(database: string = 'default', version: number = 1) {
+        this.name = database;
+        this.version = version;
+        this.tableMap = new Map<string, Table>();
+    }
+
+    on<T extends EventKey>(event: T, handle: EventMap[T]) {
+        this.eventMap[event] = handle;
+        return this
+    }
+
+    get connected() {
+        return this.idbDatabase != void 0;
+    }
+
+    async connect(name?: string, version?: number, upgrade?: (idbDatabase: IDBDatabase, event: IDBVersionChangeEvent) => any): Promise<any> {
+        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: IDBOpenDBRequest = innerDB.open(this.name, version);
+        this.eventMap.process?.call(this, IndexdbStatus.CONNECT_ING);
+
+        request.onblocked = (evt: IDBVersionChangeEvent) => {
+            logger.warn(`onblocked change from ${evt.oldVersion} to ${evt.newVersion}`, evt);
+            this.eventMap.process?.call(this, IndexdbStatus.CONNECT_CLOSE);
+            this.eventMap.blocked?.call(this, evt);
+        };
+        let returnVal = void 0;
+        request.onupgradeneeded = (event: IDBVersionChangeEvent) => {
+            logger.info(`Version change from <${event.oldVersion}> to <${event.newVersion}>`, event)
+            this.eventMap.process?.call(this, IndexdbStatus.VERSION_CHANGE);
+            const target = event.target as IDBOpenDBRequest;
+            this.idbDatabase = target.result;
+            this.eventMap.change?.call(this, this.idbDatabase, event);
+            returnVal = upgrade?.(this.idbDatabase, event);
+        };
+        return new Promise((resolve, reject) => {
+            request.onerror = (e: Event) => {
+                logger.error('onerror', e);
+                this.eventMap.process?.call(this, IndexdbStatus.CONNECT_ERROR);
+                this.eventMap.error?.call(this, e)
+                reject(e);
+            };
+            request.onsuccess = (e: Event) => {
+                logger.debug(`Connect Success`, e);
+                const target = e.target as IDBOpenDBRequest;
+                let connect: IDBDatabase = 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: Array<Index> = [];
+                        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()
+                }
+                this.eventMap.process?.call(this, IndexdbStatus.CONNECT_SUCCESS);
+                this.eventMap.success?.call(this, this.idbDatabase);
+                resolve(returnVal || this);
+            };
+        });
+    }
+
+    drop() {
+        return new Promise<Event>((resolve, reject) => {
+            let request = innerDB.deleteDatabase(this.name);
+            request.onerror = function (event: Event) {
+                reject(event)
+            };
+            request.onsuccess = function (event: Event) {
+                resolve(event)
+            };
+            this.close();
+        })
+    }
+
+    close() {
+        if (this.connected) {
+            this.eventMap.process?.call(this, IndexdbStatus.CONNECT_CLOSE);
+            this.idbDatabase?.close();
+            this.eventMap.close?.call(this);
+            this.idbDatabase = void 0;
+        }
+    }
+
+    /**
+     * 只能在版本发生变化的时候调用 即在事件change里面调用
+     * @param {string} tableName 表名
+     * @param meta 表结构信息
+     * @param idbDatabase
+     */
+    async createTable(tableName: string, meta: Omit<TableMeta, 'name'> & {
+        overwrite?: boolean
+    } = {}, idbDatabase?: IDBDatabase): Promise<Table> {
+        const {overwrite = false} = meta;
+        if (!overwrite && this.exists(tableName)) {
+            throw new Error(`Table ${tableName} is exists`);
+        }
+        const metadata: TableMeta = {...meta, name: tableName};
+        let {name = '', primaryKey = 'id', autoIncrement = true, indexes = [], rows = []} = metadata;
+        const store = (idbDatabase || this.idbDatabase)?.createObjectStore(name, {keyPath: primaryKey, autoIncrement});
+        let idxes: Array<Index> = indexes.map(({name, column, unique, multiEntry}) => {
+            store?.createIndex(name, column, {unique, multiEntry});
+            return {name, column, unique, multiEntry}
+        });
+        metadata.rows?.forEach(row => store?.add(row));
+        let table = new Table({name, primaryKey, autoIncrement, indexes: idxes}, idbDatabase || this.idbDatabase);
+        this.tableMap.set(name, table);
+        return table;
+    }
+
+
+    /**
+     * 批量建表 只能在版本发生变化的时候调用 即在事件change里面调用
+     * @param tables 表配置信息
+     * @param meta
+     * @param idbDatabase
+     */
+    async createTables(tables: Array<string | (TableMeta & { overwrite?: boolean })>, meta: Omit<ITable, 'name'> & {
+        overwrite?: boolean
+    } = {}, idbDatabase: IDBDatabase) {
+        return new Promise<Array<Table>>((resolve) => {
+            const createTables = async (idbDatabase: IDBDatabase) => {
+                let list: Array<Table> = await Promise.all(tables.map(table => {
+                    if (typeof table === 'string') {
+                        return this.createTable(table, meta, idbDatabase);
+                    } else {
+                        return this.createTable(table.name, {...meta, ...table}, idbDatabase);
+                    }
+                }));
+                resolve(list);
+            }
+            if (idbDatabase) {
+                createTables(idbDatabase);
+            } else {
+                this.connect(this.name, ++this.version, createTables);
+            }
+        })
+    }
+
+    /**
+     * 只能在版本发生变化的时候调用 即在事件change里面调用
+     * @param tableName
+     */
+    dropTable(tableName: string) {
+        if (this.exists(tableName)) {
+            this.idbDatabase?.deleteObjectStore(tableName);
+            this.tableMap.delete(tableName);
+            return true;
+        }
+        logger.error(`Table ${tableName} is not exists`)
+        throw new Error(`Table ${tableName} is not exists`);
+    }
+
+    /**
+     *
+     * @param tableName
+     * @return Table
+     */
+    table(tableName: string) {
+        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: string) {
+        return this.tableMap.has(table);
+    }
+
+    getTables() {
+        return [...this.tableMap.values()];
+    }
+}

package/src/const.ts

@@ -0,0 +1,51 @@
+let win: any = window;
+
+export const innerDB: IDBFactory = win.indexedDB || win.mozIndexedDB || win.webkitIndexedDB || win.msIndexedDB;
+
+export enum IndexdbStatus {
+    CONNECT_ING=0,
+    CONNECT_SUCCESS=1,
+    CONNECT_ERROR=2,
+    CONNECT_CHANGE=3,
+    CONNECT_CLOSE=4,
+    DATABASE_ERROR=5,
+    VERSION_CHANGE=99,
+}
+
+export class KeyRange {
+    static leq(val: any) {
+        return IDBKeyRange.upperBound(val) //All keys ≤ x
+    }
+
+    static lt(val: any) {
+        return IDBKeyRange.upperBound(val, true) //keys < x
+    }
+
+    static geq(val: any) {
+        return IDBKeyRange.lowerBound(val)//keys ≥ x
+    }
+
+    static gt(val: any) {
+        return IDBKeyRange.lowerBound(val, true) //keys > x
+    }
+
+    static between(low: any, upper: any) {
+        return IDBKeyRange.bound(low, upper)//keys ≥ x && ≤ y
+    }
+
+    static gt_lt(low: any, upper: any) {
+        return IDBKeyRange.bound(low, upper, true, true)//keys > x &&< y
+    }
+
+    static gt_leq(low: any, upper: any) {
+        return IDBKeyRange.bound(low, upper, true, false)//keys > x && ≤ y
+    }
+
+    static geq_lt(low: any, upper: any) {
+        return IDBKeyRange.bound(low, upper, false, true)//keys ≥ x &&< y
+    }
+
+    static eq(val: any) {
+        return IDBKeyRange.only(val)
+    }
+}

package/src/database.ts

@@ -0,0 +1,141 @@
+import Connection from "./connection";
+import {Row, Pagination, RowPacket} from "./table";
+
+export default class Database extends Connection {
+
+    /**
+     * 查询数据
+     * @param table 表名
+     * @param query 查询条件
+     * @param count 查询数量
+     */
+    query<R extends Row>(table: string, query?: IDBValidKey | IDBKeyRange, count: number = 1000): Promise<RowPacket<R>> {
+        return this.table(table).query(query, count)
+    }
+
+    /**
+     * 查询数据
+     * @param table 表名
+     * @param key 查询条件
+     * @param index 索引名称
+     * @param count 查询数量
+     */
+    select<R extends Row>(table: string, key?: IDBValidKey | IDBKeyRange, index?: string, count: number = 1000): Promise<RowPacket<R>> {
+        return this.table(table).select(key, count, index)
+    }
+
+    /**
+     * 获取数据
+     * @param table 表名
+     * @param key 查询条件
+     */
+    queryByKey<R extends Row>(table: string, key: IDBValidKey | IDBKeyRange): Promise<RowPacket<R>> {
+        return this.table(table).queryByKey(key)
+    }
+
+    /**
+     *
+     * @param table
+     * @param indexName 索引名称
+     * @param key key or keyRange (对应的是索引包含的列的数据)
+     * @param count 返回的列数
+     */
+    async queryByIndex<R extends Row>(table: string, indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>> {
+        return this.table(table).queryByIndex(indexName, key, count)
+    }
+
+    /**
+     * 获取数据
+     * @param table
+     * @param id
+     * @param indexName
+     */
+    async queryById<R extends Row>(table: string, id: any | Array<any>, indexName?: string): Promise<R> {
+        return this.table(table).queryById(id, indexName);
+    }
+
+    /**
+     * 获取数据
+     * @param table 表名
+     * @param key 查询条件
+     */
+    count(table: string, key: IDBValidKey | IDBKeyRange) {
+        return this.table(table).count(key)
+    }
+
+    /**
+     * 插入数据
+     * @param table
+     * @param data
+     */
+    insert(table: string, data: Array<Record<string, any>>) {
+        return this.table(table).insert(data)
+    }
+
+    /**
+     * 更新数据
+     * @param table 表名
+     * @param modify 更新内容
+     * @param key 条件
+     */
+    update(table: string, modify: Row, key?: IDBValidKey | IDBKeyRange | null) {
+        return this.table(table).update(modify, key)
+    }
+
+    /**
+     * 删除数据
+     * @param table 表名
+     * @param key 索引名称
+     */
+    delete(table: string, key: IDBValidKey | IDBKeyRange) {
+        return this.table(table).delete(key)
+    }
+
+    /**
+     * 清空表
+     * @param table 表名
+     */
+    truncate(table: string) {
+        return this.table(table).truncate()
+    }
+
+    /**
+     * 获取内存分页模型对象
+     * @param table
+     * @param pageSize
+     */
+    getPagination<R extends Row>(table: string, pageSize: number = 10): Promise<Pagination<R>> {
+        return this.table(table).getPagination<R>(pageSize, 1)
+    }
+
+    /**
+     * 扫描数据
+     * @param table 表名
+     * @param key key or keyRange (对应的是主键的数据)
+     * @param direction 游标方向
+     * @param indexName 索引名称
+     */
+    async scan<R extends Row>(table: string, key?: IDBValidKey | IDBKeyRange, direction: IDBCursorDirection = 'next', indexName?: string): Promise<RowPacket<R>> {
+        return this.table(table).scan(key, direction, indexName)
+    }
+
+    /**
+     * 获取所有数据
+     * @param table
+     */
+    getAllData<R extends Row>(table: string): Promise<Array<R>> {
+        return this.table(table).getAllData();
+    }
+
+    /**
+     * 分页查询
+     * @param table
+     * @param pageNo 页码
+     * @param pageSize 每页数量
+     * @param key (对应的是主键的数据)
+     * @param indexName 索引名称
+     */
+    async paginate<R extends Row>(table: string, pageNo: number = 1, pageSize: number = 10, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>> {
+        return this.table(table).paginate(pageNo, pageSize, key, indexName)
+    }
+}

package/src/index.ts

@@ -0,0 +1,150 @@
+import {IndexdbStatus, innerDB, KeyRange} from "./const";
+import Database from "./database";
+import Connection from "./connection";
+import Table, {TableMeta} from "./table";
+import {Logger} from "./com";
+
+
+const logger = Logger.getLogger("Driver")
+
+class Driver {
+    private readonly name: string;
+    private version: number;
+    private readonly tables: Array<TableMeta> = [];
+
+    constructor(name: string, version: number = 0) {
+        this.name = name;
+        this.version = version;
+    }
+
+    defineTables(...tables: Array<TableMeta>): this {
+        this.tables.push(...tables);
+        logger.debug(`Define tables: ${tables.map(t => t.name).join(', ')}`);
+        return this;
+    }
+
+    private async hasChange(database: Database): Promise<boolean> {
+        // 获取表列表
+        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 = tableMeta.indexes?.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;
+    }
+
+    async connect(version?: number): Promise<Database> {
+        const databases = await 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 as IDBOpenDBRequest).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, {...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);
+                }
+            }
+        });
+        await database.connect();
+
+        if (await this.hasChange(database)) {
+            database.close();
+            await database.connect(this.name, ++this.version)
+        }
+
+        return database;
+    }
+}
+
+export {IndexdbStatus, KeyRange, Connection, Table, Logger, Driver};
+
+
+export default Driver;

package/src/table.ts

@@ -0,0 +1,531 @@
+import {Logger} from "./com";
+
+const logger = Logger.getLogger('Table');
+
+
+const _getObjectStore = (table: Table, mode: IDBTransactionMode = 'readonly') => {
+    const trans = table.database?.transaction(table.name, mode);
+    if (!trans) {
+        throw new Error('database not open');
+    }
+    trans.oncomplete = (event: any) => {
+        logger.debug(`Table ${table.name} transaction success`, event);
+    }
+    trans.onerror = (event: any) => {
+        logger.error(`Table ${table.name} transaction error`, event)
+    };
+    return trans.objectStore(table.name);
+};
+
+const _request = async <T> (request: IDBRequest<T>): Promise<T> => {
+    return new Promise<any>((resolve, reject) => {
+        request.onsuccess = (e: any) => {
+            resolve(e.target.result)
+        };
+        request.onerror = (e: any) => {
+            reject(e.target.error)
+        }
+    })
+};
+
+
+export type Index = {
+    name: string;
+    column: Array<string> | string;
+    unique?: boolean;
+    multiEntry?: boolean;
+}
+
+export type ITable = {
+    name: string;
+    primaryKey?: string | string[];
+    autoIncrement?: boolean;
+    indexes?: Array<Index>;
+}
+
+export type Row = Record<string, any>;
+
+export type Rows = Array<Row>;
+
+export type TableMeta = ITable & { rows?: Rows };
+
+export class RowPacket<T extends Row> extends Array<T> {
+
+    constructor(rows: Array<T> = []) {
+        super(...rows)
+    }
+
+    /**
+     * 去重
+     * @param column
+     */
+    distinct(column?: string | ((row: T) => any)): Array<T> {
+        if (!column) {
+            return this;
+        }
+        let set = new Set<any>();
+        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;
+        });
+    }
+
+    /**
+     * 数组转map
+     */
+    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>;
+    mapping<K, V>(keyFn: (row: T, index: number, array: Array<T>) => K,
+                  valFn?: (row: T, index: number, array: Array<T>) => V): Map<K, V | T> {
+        if (!keyFn) throw new Error('Undefined group by field');
+        let mapping = new Map<K, V | T>();
+        this.forEach((item, index, array) => {
+            let unionKey: K = 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;
+    }
+
+    /**
+     * 按指定key分组
+     */
+    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>>;
+    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<T | V>> {
+        if (!key) throw new Error('Undefined group by field');
+        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;
+            if (!group.has(unionKey)) {
+                group.set(unionKey, [value]);
+            } else {
+                group.get(unionKey)?.push(value);
+            }
+        });
+        return group;
+    }
+
+    /**
+     * 找出符合条件的最大行
+     * @param keyFn
+     */
+    max(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): {
+        value: number;
+        rows: Array<T>
+    } {
+        let max = 0;
+        let maxRows: Array<T> = [];
+        this.forEach((item, index, array) => {
+            let unionKey: number = 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: keyof T | ((row: T, index: number, array: Array<T>) => number)): {
+        value: number;
+        rows: Array<T>
+    } {
+        let min = 0;
+        let minRows: Array<T> = [];
+        this.forEach((item, index, array) => {
+            let unionKey: number = 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
+        };
+    }
+
+    /**
+     * 求和
+     * @param keyFn
+     */
+    sum(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): number {
+        return this.reduce((sum, item, index, array) => {
+            return sum + (typeof keyFn === 'function' ? keyFn.call(this, item, index, array) : item[keyFn]);
+        }, 0)
+    }
+
+    /**
+     * 获取平均值
+     * @param keyFn
+     */
+    average(keyFn: keyof T | ((row: T, index: number, array: Array<T>) => number)): number {
+        return this.sum(keyFn) / this.length;
+    }
+}
+
+
+/**
+ * 分页模型 包含所有数据，通过分页索引和分页大小进行数据截取
+ */
+export class Pagination<T extends Row> {
+    /**
+     * 数据源
+     * @private
+     */
+    private readonly _data: Array<T>;
+    /**
+     * 分页大小
+     * @private
+     */
+    private readonly _pageSize: number;
+    /**
+     * 当前页索引 默认1
+     * @private
+     */
+    private _pageIndex: number;
+    /**
+     * 总数据量
+     * @private
+     */
+    private readonly _total: number;
+
+    constructor(data: Array<T>, pageSize: number = 10, pageIndex: number = 1) {
+        this._data = data;
+        this._pageSize = pageSize < 1 ? 10 : pageSize;
+        this._pageIndex = pageIndex < 0 ? 1 : pageIndex;
+        this._total = data.length;
+    }
+
+    /**
+     * 总页数
+     */
+    get totalPage(): number {
+        return Math.ceil(this._total / this._pageSize);
+    }
+
+    /**
+     * 总数据量
+     */
+    get total(): number {
+        return this._total;
+    }
+    /**
+     * 当前页索引
+     */
+    get pageIndex(): number {
+        return this._pageIndex;
+    }
+    /**
+     * 当前页大小
+     */
+    get pageSize(): number {
+        return this._pageSize;
+    }
+    /**
+     * 是否有下一页
+     */
+    get hasNext(): boolean {
+        return this._pageIndex * this._pageSize < this._total;
+    }
+
+    /**
+     * 是否有上一页
+     */
+    get hasPrev(): boolean {
+        return this._pageIndex > 1;
+    }
+
+    /**
+     * 当前页数据
+     */
+    get data(): Array<any> {
+        let start = (this._pageIndex - 1) * this._pageSize;
+        let end = start + this._pageSize;
+        return this._data.slice(start, end);
+    }
+    /**
+     * 上一页
+     */
+    prev(): boolean {
+        if (this.hasPrev) {
+            this._pageIndex--;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 下一页
+     */
+    next(): boolean {
+        if (this.hasNext) {
+            this._pageIndex++;
+            return true;
+        }
+        return false;
+    }
+}
+
+export default class Table implements ITable{
+    readonly name : string;
+    readonly primaryKey: string | string[] = "id";
+    readonly autoIncrement: boolean = false;
+    readonly indexes: Array<Index> = [];
+    readonly database?: IDBDatabase;
+    /**
+     *
+     * @param table
+     * @param {Database} database 数据库对象 @see Database
+     */
+    constructor(table: ITable | string, database?: IDBDatabase) {
+        let tableMeta: TableMeta;
+        if (typeof table === 'string') {
+            tableMeta = {name: table}
+        } else {
+            tableMeta = {...table};
+        }
+        const {name = '', primaryKey = 'id', autoIncrement = true, indexes = []} = tableMeta;
+        this.name = name;
+        this.primaryKey = primaryKey;
+        this.autoIncrement = autoIncrement;
+        this.database = database;
+        this.indexes = (indexes || []).map(idx => {
+            return {
+                unique: false,
+                multiEntry: false,
+                ...idx
+            }
+        });
+    }
+
+    get meta(): TableMeta {
+        return {
+            name: this.name,
+            primaryKey: this.primaryKey,
+            autoIncrement: this.autoIncrement,
+            indexes: this.indexes
+        }
+    }
+
+    /**
+     *
+     * 插入数据 对象或者数据数组 如果数据中包含主键，则会查找是否存在，如果存在则会报错
+     * @param data 数据
+     */
+    async insert(data: Row | Rows): Promise<Array<IDBValidKey>> {
+        const store = _getObjectStore(this, 'readwrite');
+        let results: Array<any> = [];
+        let rows: Rows = Array.isArray(data) ? data : [data];
+        for (let row of rows) {
+            let result = await _request(store.add(row));
+            results.push(result);
+        }
+        return results
+    }
+
+    /**
+     * 更新modify 如果对象中有key会自动从对象中提取key 如果没有key会变成新增数据
+     * @param modify 更新内容
+     * @param key 条件
+     */
+    async update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey> {
+        const store = _getObjectStore(this, 'readwrite');
+        return _request(store.put(modify, key as IDBValidKey));
+    }
+
+    /**
+     * 根据主键值删除
+     * @param key
+     */
+    async delete(key: IDBValidKey | IDBKeyRange) {
+        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;
+    }
+
+    /**
+     * 清空表
+     */
+    truncate (): Promise<void> {
+        return _request(_getObjectStore(this, 'readwrite').clear())
+    }
+
+    /**
+     * 根据索引名称删除索引
+     * @param name
+     */
+    dropIndex (name:string) {
+        return _getObjectStore(this, 'readwrite').deleteIndex(name)
+    }
+
+    /**
+     * 获取指定范围内的主键列表
+     * @param key @see{@link IDBKeyRange | IDBValidKey}
+     * @param count 获取数量
+     */
+    keys (key?: IDBValidKey | IDBKeyRange | null, count?: number) {
+        return _request(_getObjectStore(this).getAllKeys(key, count));
+    }
+
+    /**
+     * 统计数量
+     * @param key
+     */
+    count(key?: IDBValidKey | IDBKeyRange) {
+        return _request(_getObjectStore(this).count(key))
+    }
+
+    /**
+     *
+     * @param key
+     * @param count
+     */
+    async query<R extends Row>(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>> {
+        let rows = await _request(_getObjectStore(this).getAll(key, count));
+        return new RowPacket<R>(rows);
+    }
+
+    /**
+     *
+     * @param indexName 索引名称
+     * @param key key or keyRange (对应的是索引包含的列的数据)
+     * @param count 返回的列数
+     */
+    async queryByIndex<R extends Row>(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<R>> {
+        const store = _getObjectStore(this);
+        const index = store.index(indexName);
+        let rows: Array<any> = await _request(index.getAll(key || null, count));
+        return new RowPacket<R>(rows);
+    }
+
+    /**
+     *
+     * @param key 数据条件 如果是联合索引则需要指定每个索引列的值，以数组方式
+     * @param count 数量
+     * @param indexName 索引名称
+     */
+    select<R extends Row>(key?: IDBValidKey | IDBKeyRange, count?: number, indexName?: string): Promise<RowPacket<R>> {
+        if (!indexName) {
+            return this.query(key, count);
+        }
+        return this.queryByIndex(indexName, key, count);
+    }
+
+    /**
+     * @param key (对应的是主键的数据)
+     */
+    async queryByKey<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<RowPacket<R>> {
+        let rows = await _request(_getObjectStore(this).get(key))
+        return new RowPacket<R>(rows);
+    }
+
+    /**
+     * 分页查询
+     * @param pageNo 页码
+     * @param pageSize 每页数量
+     * @param key (对应的是主键的数据)
+     * @param indexName 索引名称
+     */
+    async paginate<R extends Row>(pageNo: number = 1, pageSize: number = 10, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>> {
+        const store = _getObjectStore(this);
+        let request: IDBRequest<any[]>;
+        let count = pageSize * pageNo;
+        if (indexName) {
+            const index = store.index(indexName);
+            request = index.getAll(key, count);
+        } else {
+            request = store.getAll(key, count);
+        }
+        let rows: Array<any> = await _request(request);
+        return new RowPacket(rows.slice(pageSize * (pageNo - 1), pageSize * pageNo));
+    }
+
+    /**
+     * 根据主键查询  如果是联合主键 则id是数组
+     * @param id id名称
+     * @param indexName 索引名称
+     */
+    async queryById<R extends Row>(id: any | Array<any>, indexName?: string): Promise<R> {
+        const [result] = await this.select(IDBKeyRange.only(id), 1, indexName);
+        return result as R;
+    }
+
+    /**
+     * 通过游标查询
+     * @param key
+     * @param direction
+     * @param indexName
+     */
+    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) {
+            request = store.openCursor(key, direction);
+        } else {
+            request = store.index(indexName).openCursor(key, direction);
+        }
+
+        return new Promise((resolve, reject) => {
+            let packets: RowPacket<R> = new RowPacket<R>([]);
+            request.onsuccess = function (event: Event) {
+                const req = event.target as IDBRequest<IDBCursorWithValue>;
+                const cursor = req.result
+                if (cursor) {
+                    packets.push(cursor.value)
+                    cursor.continue()
+                } else {
+                    resolve(packets);
+                }
+            }
+
+            request.onerror = function (event: Event) {
+                reject(event)
+            }
+        });
+    }
+
+    /**
+     * 获取所有数据
+     */
+    getAllData<R extends Row>(): Promise<Array<R>> {
+        const store = _getObjectStore(this);
+        return _request(store.getAll())
+    }
+
+    /**
+     * 获取一个内存分页模型
+     */
+    async getPagination<R extends Row>(pageSize: number = 10, pageIndex: number = 1): Promise<Pagination<R>> {
+        const rows = await this.getAllData<R>();
+        return new Pagination<R>(rows, pageSize, pageIndex)
+    }
+}