xdriver 2.0.1 → 2.0.3

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