xdriver 1.0.8 → 1.1.1

package/lib/Database.d.ts

@@ -3,17 +3,20 @@ export default class Database {
     private name;
     private version;
     connect: any;
+    private initialized;
+    readonly tables: Map<string, Table>;
     readonly events: any;
     constructor(name: string, version?: number);
+    initialize(initialized: Function): this;
     on(event: any, fn?: Function): this;
     isOpen(): boolean;
-    open(name?: string | undefined, version?: number | undefined): Promise<unknown>;
+    open(name?: string | undefined, version?: any): Promise<unknown>;
     drop(): Promise<unknown>;
     close(): void;
-    createTable(tab: string | object, options?: object): Table;
-    createTables(tables: Array<string | object>, options?: object): Table[];
-    dropTable(tableName: string): any;
-    table(tableName: string): Table;
-    exists(table: string): any;
-    tables(): any;
+    createTable(tableName: string, options?: object): Table;
+    createTables(tables: Array<string>, options?: object): Table[];
+    dropTable(tableName: string): boolean;
+    protected table(tableName: string): Table;
+    exists(table: string): boolean;
+    getTables(): IterableIterator<Table>;
 }

package/lib/Database.js

@@ -1,6 +1,7 @@
 import { _instance } from "./Utils";
 import { IndexdbStatus, innerDB } from "./Const";
 import Table from "./Table";
+import { TableIndex } from "./index";
 export default class Database {
     constructor(name, version) {
         this.version = 1;
@@ -8,13 +9,10 @@ export default class Database {
             process: (status) => {
             },
             success: () => {
-                console.debug("success");
             },
             close: () => {
-                console.debug("close");
             },
             change: () => {
-                console.debug("change");
             },
             error: () => {
             }
@@ -22,6 +20,15 @@ export default class Database {
         this.name = name;
         this.version = version;
         this.connect = null;
+        this.initialized = () => { };
+        this.tables = new Map();
+    }
+    initialize(initialized) {
+        if (this.isOpen()) {
+            throw new Error('You must be call this method before open');
+        }
+        this.initialized = initialized;
+        return this;
     }
     on(event, fn) {
         if (!_instance(event, Object)) {
@@ -39,6 +46,9 @@ export default class Database {
         return this.connect != null;
     }
     open(name, version) {
+        if (!name && !version && this.isOpen()) {
+            return Promise.resolve(this);
+        }
         this.name = name || this.name;
         this.version = version || this.version;
         const request = innerDB.open(this.name, version);
@@ -52,9 +62,24 @@ export default class Database {
             this.events.process(IndexdbStatus.CONNECT_CLOSE);
             this.events.close.call(this, e.target.result);
         };
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             request.onsuccess = (e) => {
-                this.connect = e.target.result;
+                let connect = e.target.result;
+                let objectStoreNames = connect.objectStoreNames;
+                let transaction = connect.transaction(objectStoreNames);
+                for (let i = 0; i < objectStoreNames.length; i++) {
+                    let table = objectStoreNames.item(i);
+                    let objectStore = transaction.objectStore(table);
+                    let { indexNames = [], keyPath: primaryKey, name, autoIncrement = true } = objectStore;
+                    let indexes = [];
+                    for (let j = 0; j < indexNames.length; j++) {
+                        let indexName = indexNames.item(j);
+                        let { keyPath, name, multiEntry, unique } = objectStore.index(indexName);
+                        indexes.push(new TableIndex(name, keyPath, unique, multiEntry));
+                    }
+                    this.tables.set(name, new Table({ name, primaryKey, autoIncrement, indexes }, this));
+                }
+                this.connect = connect;
                 this.events.process(IndexdbStatus.CONNECT_SUCCESS);
                 this.connect.onerror = this.connect.onabort = (e) => {
                     const error = e.target.error;
@@ -68,7 +93,7 @@ export default class Database {
                 this.events.process(IndexdbStatus.CONNECT_SUCCESS);
                 this.connect = e.target.result;
                 this.events.change.call(this, this.connect);
-                resolve(this);
+                this.initialized();
             };
         });
     }
@@ -92,39 +117,45 @@ export default class Database {
             this.connect = null;
         }
     }
-    createTable(tab, options) {
-        let table = tab;
-        if (_instance(tab, String)) {
-            table = Object.assign({ name: tab }, options);
+    createTable(tableName, options) {
+        if (this.exists(tableName)) {
+            throw new Error(`Table ${tableName} is exists`);
         }
-        return new Table(table, this);
+        let { name = '', primaryKey = 'id', autoIncrement = true, indexes = [], data = [] } = Object.assign({ name: tableName }, options);
+        const store = this.connect.createObjectStore(name, { keyPath: primaryKey, autoIncrement });
+        let idxes = indexes.map(({ name, column, unique, multiEntry }) => {
+            store.createIndex(name, column, { unique, multiEntry });
+            return new TableIndex(name, column, unique, multiEntry);
+        });
+        data.forEach(item => store.add(item));
+        let tab = new Table({ name, primaryKey, autoIncrement, indexes: idxes }, this);
+        this.tables.set(name, tab);
+        return tab;
     }
     createTables(tables, options) {
         return tables.map(table => {
-            let opts = Object.assign({}, options);
-            if (_instance(table, String)) {
-                Object.assign(opts, { name: table });
-            }
-            else {
-                Object.assign(opts, table);
-            }
-            return new Table(opts, this);
+            return this.createTable(table, options);
         });
     }
     dropTable(tableName) {
-        return this.connect.deleteObjectStore(tableName);
+        if (this.exists(tableName)) {
+            this.tables.delete(tableName);
+            this.connect.deleteObjectStore(tableName);
+            return true;
+        }
+        return false;
     }
     table(tableName) {
-        if (!this.exists(tableName)) {
-            throw new Error(`table ${tableName} not exists!`);
+        let table = this.tables.get(tableName);
+        if (typeof table !== "undefined") {
+            return table;
         }
-        return new Table({ name: tableName }, this);
+        throw new Error(`table ${tableName} not exists!`);
     }
     exists(table) {
-        const tables = this.tables();
-        return tables && tables.contains(table);
+        return this.tables.has(table);
     }
-    tables() {
-        return this.connect['objectStoreNames'];
+    getTables() {
+        return this.tables.values();
     }
 }

package/lib/Driver.d.ts

@@ -2,10 +2,12 @@ import { KeyRange } from "./Const";
 import Database from "./Database";
 declare class Driver extends Database {
     insert(table: string, data: Array<any>): Promise<unknown>;
-    select(table: string, keyRange?: KeyRange, limit?: number): any;
+    query(table: string, keyRange?: KeyRange, limit?: number): any;
+    select(table: string, where: any, options?: any): any;
     selectByKey(table: string, key: any): any;
     count(table: string, keyRange?: KeyRange): any;
     update(table: string, modify: any, where: any): Promise<unknown> | undefined;
+    merge(table: string, row: any): Promise<unknown> | undefined;
     delete(table: string, key: any): any;
     truncate(table: string): any;
 }

package/lib/Driver.js

@@ -3,9 +3,12 @@ class Driver extends Database {
     insert(table, data) {
         return this.table(table).insert(data);
     }
-    select(table, keyRange, limit) {
+    query(table, keyRange, limit) {
         return this.table(table).query(keyRange, limit);
     }
+    select(table, where, options) {
+        return this.table(table).select(where, options);
+    }
     selectByKey(table, key) {
         return this.table(table).queryByKey(key);
     }
@@ -15,6 +18,9 @@ class Driver extends Database {
     update(table, modify, where) {
         return this.table(table).update(modify, where);
     }
+    merge(table, row) {
+        return this.table(table).merge(row);
+    }
     delete(table, key) {
         return this.table(table).delete(key);
     }

package/lib/Table.d.ts

@@ -7,12 +7,11 @@ export default class Table {
     readonly autoIncrement: boolean;
     readonly indexes: Array<TableIndex>;
     readonly database: Database;
-    constructor({ name, primaryKey, autoIncrement, indexes, data }: {
+    constructor({ name, primaryKey, autoIncrement, indexes }: {
         name?: string | undefined;
         primaryKey?: string | undefined;
         autoIncrement?: boolean | undefined;
         indexes?: never[] | undefined;
-        data?: never[] | undefined;
     }, database: Database);
     insert(data: Array<any>): Promise<unknown>;
     update(modify: any, where?: any): Promise<unknown> | undefined;

package/lib/Table.js

@@ -18,7 +18,7 @@ const _request = (request, success) => {
     });
 };
 export default class Table {
-    constructor({ name = '', primaryKey = 'id', autoIncrement = true, indexes = [], data = [] }, database) {
+    constructor({ name = '', primaryKey = 'id', autoIncrement = true, indexes = [] }, database) {
         this.primaryKey = "id";
         this.autoIncrement = false;
         this.indexes = [];
@@ -26,11 +26,7 @@ export default class Table {
         this.primaryKey = primaryKey;
         this.autoIncrement = autoIncrement;
         this.database = database;
-        if (!database.exists(name)) {
-            const store = database.connect.createObjectStore(name, { keyPath: this.primaryKey, autoIncrement });
-            indexes.forEach(({ name, column, unique, multiEntry }) => store.createIndex(name, column, { unique, multiEntry }));
-            data.forEach(item => store.add(item));
-        }
+        this.indexes = indexes;
     }
     insert(data) {
         const arr = _instance(data, Array) ? data : [data];
@@ -107,7 +103,7 @@ export default class Table {
         if (!where) {
             return this.query();
         }
-        let { index = '', limit = void 0, useIndex = false } = options;
+        let { index = '', limit = void 0, useIndex = false } = options || {};
         if (useIndex && index) {
             return this.queryByIndex(index, where, limit);
         }

package/lib/TableIndex.d.ts

@@ -1,7 +1,7 @@
 export default class TableIndex {
     readonly name: string;
-    readonly column: string;
+    readonly column: Array<string> | string;
     readonly unique: boolean;
     readonly multiEntry: boolean;
-    constructor(name: string, column: string, unique?: boolean, multiEntry?: boolean);
+    constructor(name: string, column: Array<string> | string, unique?: boolean, multiEntry?: boolean);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xdriver",
-  "version": "1.0.08",
+  "version": "1.1.1",
   "description": "A simple driver for IndexDB",
   "main": "./lib/index",
   "files": [