xdriver 2.0.1 → 2.0.3

package/README.md

@@ -1,108 +1,33 @@
-## 文档懒得写，更详细API查看源码 目录：src/ts/
+## 说明
 
-### indexDB
+### 初始化Connection
 
+```javascript
+import {KeyRange, Driver} from 'xdriver';
+// 初始化数据库驱动
+const driver = new Driver('demo', version);
+// 定义表结构以及初始化数据
+driver.defineTables({
+    name: 'player',
+    primaryKey: 'id',
+    autoIncrement: true,
+    indexes: [
+        {name: 'age_index', column: 'age'},
+        {name: 'name_index', column: 'name'},
+        {name: 'double_index', column: ['sex', 'age']},
+    ],
+    rows: [{name: 'xxx', age: '', sex: ''}] //初始化数据
+});
+const connect = await driver.connect();
 ```
-import Driver from 'ndriver';
-const driver = new Driver('demo', version?);
-driver.on("process", function (state) {
-    console.log(state)
-})
-driver.open().then(function () {
-    var arrPlayers = []
-    for(let i=0; i<100; i++) {
-        arrPlayers.push({
-            name: `韩梅梅${i}`,
-            sex: `女${i}`
-        })
-    }
-    driver.createTable({
-        name: 'player',
-        primaryKey: 'id',
-        autoIncrement: true,
-        indexes: [
-          {name: 'name_index', column: 'name', unique: true},
-        ],
-        data : arrPlayers
-    })
-})
-```
-
-### API
-#### constructor(name, version?)
-	name: 数据库名字
-	version: 数据库版本 默认1
-	eg: var driver = new Driver('database')
-### open
-	打开数据库连接 返回promise对象 在resolve中可以创建表或者删除表 
-	driver.open().then(() => {
-	    driver.createTable({
-	        name: 'table',
-	        primaryKey: 'key',
-	        indexes: [
-	            {name: 'name_index', column: 'key', unique: true},
-	        ],
-	    })
-	})
-#### Driver.prototype.insert(table, data)
-	table: 表名
-	data: 需要插入的数据 obj or array
-	eg: driver.insert({key: 'key', name: '', ...})
-#### Driver.prototype.select(table, keyRange?, limit?)
-	table: 表名
-	keyRange: KeyRange 包含多种比较操作
-	limit: 取出记录数
-	eg: driver.select('table', keyRange.eq('key'), 1).then(rs => console.log(rs))
-	
-#### Driver.prototype.selectByKey(table, key) 
-	table:表名
-	key: 主键
-	eg: driver.selectByKey('key').then(rs => console.log(rs))
 
-#### Driver.prototype. count (table, keyRange?)
-	根据条件统计记录数
-	table: 表名
-	keyRange: @see select
-	eg: driver.count('table').then(size => console.log(size))
-#### Driver.prototype. update (table, modify, where?)
-	 数据更新，如果数据不存在则新增
-	 table: 表名
-	 modify: 修改的对象
-	 where：条件
-	 eg: driver.update('table', {name: 'xxxx'}, {key: 'key'})
-#### Driver.prototype.delete (table, key)
-	table: 表名
-	key: 主键
-	根据主键删除
-	eg: driver.delete('table', 'key')
-	
-#### Driver.prototype.truncate(table)
-	清空某张表
-    table：表名
+### 操作表
 
-### 示例
+```javascript
+const player = connect.table('player');
 
-```
-const driver = new Driver('pallet', 1);
-driver.on("process", function (state) {
-    console.log(state)
-})
-driver.open().then(function () {
-    var arrPlayers = []
-    for(let i=0; i<100; i++) {
-        arrPlayers.push({
-            name: `韩梅梅${i}`,
-            sex: `女${i}`
-        })
-    }
-    driver.createTable({
-        name: 'player',
-        primaryKey: 'id',
-        autoIncrement: true,
-        indexes: [
-          {name: 'name_index', column: 'name', unique: true},
-        ],
-        data : arrPlayers
-    })
-})
+let results = await player.queryByIndex('age_index', KeyRange.between(10, 20));
+results = await player.queryByIndex('double_index', KeyRange.eq(['女3', 0]));
+results = await player.query(KeyRange.between(10, 20))
+results = connect.queryByIndex('tableName', 'indexName', KeyRange.between(10, 20))
 ```

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 {};