xdriver 1.0.1

package/README.md

@@ -0,0 +1,108 @@
+## 文档懒得写，更详细API查看源码 目录：src/ts/
+
+### indexDB
+
+```
+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：表名
+
+### 示例
+
+```
+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
+    })
+})
+```

package/lib/Const.d.ts

@@ -0,0 +1,32 @@
+export declare const innerDB: any;
+export declare enum TransactionMode {
+    READ_ONLY = "readonly",
+    READ_WRITE = "readwrite",
+    READ_WRITE_FLUSH = "readwriteflush",
+    VERSION_CHANGE = "versionchange"
+}
+export declare enum CursorDirection {
+    NEXT,
+    NEXT_NO_DUPLICATE,
+    PREV,
+    PREV_NO_DUPLICATE
+}
+export declare class KeyRange {
+    static leq(x: any): any;
+    static lt(x: any): any;
+    static geq(x: any): any;
+    static gt(x: any): any;
+    static between(x: any, y: any): any;
+    static gt_lt(x: any, y: any): any;
+    static gt_leq(x: any, y: any): any;
+    static geq_lt(x: any, y: any): any;
+    static eq(x: any, y: any): any;
+}
+export declare enum IndexdbStatus {
+    CONNECT_ING = 0,
+    CONNECT_SUCCESS = 1,
+    CONNECT_ERROR = 2,
+    CONNECT_CHANGE = 3,
+    CONNECT_CLOSE = 4,
+    DATABASE_ERROR = 0
+}

package/lib/Const.js

@@ -0,0 +1,57 @@
+let win = window;
+const DBCursor = win.IDBCursor;
+const DBKeyRange = win.IDBKeyRange || win.webkitIDBKeyRange || win.msIDBKeyRange;
+export const innerDB = win.indexedDB || win.mozIndexedDB || win.webkitIndexedDB || win.msIndexedDB;
+const DBTransaction = win.IDBTransaction || win.webkitIDBTransaction || win.msIDBTransaction;
+export var TransactionMode;
+(function (TransactionMode) {
+    TransactionMode["READ_ONLY"] = "readonly";
+    TransactionMode["READ_WRITE"] = "readwrite";
+    TransactionMode["READ_WRITE_FLUSH"] = "readwriteflush";
+    TransactionMode["VERSION_CHANGE"] = "versionchange";
+})(TransactionMode || (TransactionMode = {}));
+export var CursorDirection;
+(function (CursorDirection) {
+    CursorDirection[CursorDirection["NEXT"] = DBCursor.NEXT] = "NEXT";
+    CursorDirection[CursorDirection["NEXT_NO_DUPLICATE"] = DBCursor.NEXT_NO_DUPLICATE] = "NEXT_NO_DUPLICATE";
+    CursorDirection[CursorDirection["PREV"] = DBCursor.PREV] = "PREV";
+    CursorDirection[CursorDirection["PREV_NO_DUPLICATE"] = DBCursor.PREV_NO_DUPLICATE] = "PREV_NO_DUPLICATE";
+})(CursorDirection || (CursorDirection = {}));
+export class KeyRange {
+    static leq(x) {
+        return DBKeyRange.upperBound(x);
+    }
+    static lt(x) {
+        return DBKeyRange.upperBound(x, true);
+    }
+    static geq(x) {
+        return DBKeyRange.lowerBound(x);
+    }
+    static gt(x) {
+        return DBKeyRange.lowerBound(x, true);
+    }
+    static between(x, y) {
+        return DBKeyRange.bound(x, y);
+    }
+    static gt_lt(x, y) {
+        return DBKeyRange.bound(x, y, true, true);
+    }
+    static gt_leq(x, y) {
+        return DBKeyRange.bound(x, y, true, false);
+    }
+    static geq_lt(x, y) {
+        return DBKeyRange.bound(x, y, false, true);
+    }
+    static eq(x, y) {
+        return DBKeyRange.only(x);
+    }
+}
+export var IndexdbStatus;
+(function (IndexdbStatus) {
+    IndexdbStatus[IndexdbStatus["CONNECT_ING"] = 0] = "CONNECT_ING";
+    IndexdbStatus[IndexdbStatus["CONNECT_SUCCESS"] = 1] = "CONNECT_SUCCESS";
+    IndexdbStatus[IndexdbStatus["CONNECT_ERROR"] = 2] = "CONNECT_ERROR";
+    IndexdbStatus[IndexdbStatus["CONNECT_CHANGE"] = 3] = "CONNECT_CHANGE";
+    IndexdbStatus[IndexdbStatus["CONNECT_CLOSE"] = 4] = "CONNECT_CLOSE";
+    IndexdbStatus[IndexdbStatus["DATABASE_ERROR"] = 0] = "DATABASE_ERROR";
+})(IndexdbStatus || (IndexdbStatus = {}));

package/lib/Database.d.ts

@@ -0,0 +1,18 @@
+import Table from "./Table";
+export default class Database {
+    private name;
+    private version;
+    connect: any;
+    readonly events: any;
+    constructor(name: string, version?: number);
+    on(event: any, fn?: Function): this;
+    isOpen(): boolean;
+    open(name?: string | undefined, version?: number | undefined): Promise<unknown>;
+    drop(): Promise<unknown>;
+    close(): void;
+    createTable(tab: string | object): Table;
+    dropTable(tableName: string): any;
+    table(tableName: string): Table;
+    exists(table: string): any;
+    tables(): any;
+}

package/lib/Database.js

@@ -0,0 +1,118 @@
+import { _instance } from "./Utils";
+import { IndexdbStatus, innerDB } from "./Const";
+import Table from "./Table";
+export default class Database {
+    constructor(name, version) {
+        this.version = 1;
+        this.events = {
+            process: (status) => {
+            },
+            success: () => {
+                console.debug("success");
+            },
+            close: () => {
+                console.debug("close");
+            },
+            change: () => {
+                console.debug("change");
+            },
+            error: () => {
+            }
+        };
+        this.name = name;
+        this.version = version;
+        this.connect = null;
+    }
+    on(event, fn) {
+        if (!_instance(event, Object)) {
+            Object.keys(event).forEach((e) => this.on(e, event[e]));
+        }
+        else {
+            if (!(event in this.events)) {
+                throw new Error(`Unsupport event type ${event}!`);
+            }
+            this.events[event.toString()] = fn;
+        }
+        return this;
+    }
+    isOpen() {
+        return this.connect != null;
+    }
+    open(name, version) {
+        this.name = name || this.name;
+        this.version = version || this.version;
+        const request = innerDB.open(this.name, version);
+        this.events.process(IndexdbStatus.CONNECT_ING);
+        request.onerror = (e) => {
+            const error = e.target.error;
+            this.events.process(IndexdbStatus.CONNECT_ERROR);
+            this.events.error.call(this, error);
+        };
+        request.onclose = (e) => {
+            this.events.process(IndexdbStatus.CONNECT_CLOSE);
+            this.events.close.call(this, e.target.result);
+        };
+        return new Promise((resolve) => {
+            request.onsuccess = (e) => {
+                this.connect = e.target.result;
+                this.events.process(IndexdbStatus.CONNECT_SUCCESS);
+                this.connect.onerror = this.connect.onabort = (e) => {
+                    const error = e.target.error;
+                    this.events.process(IndexdbStatus.DATABASE_ERROR);
+                    this.events.error.call(this, error);
+                };
+                this.events.success.call(this, this.connect);
+                resolve(this);
+            };
+            request.onupgradeneeded = (e) => {
+                this.events.process(IndexdbStatus.CONNECT_SUCCESS);
+                this.connect = e.target.result;
+                this.events.change.call(this, this.connect);
+                resolve(this);
+            };
+        });
+    }
+    drop() {
+        this.close();
+        return new Promise((resolve, reject) => {
+            let request = innerDB.deleteDatabase(this.name);
+            request.onerror = function (event) {
+                reject(event);
+            };
+            request.onsuccess = function (event) {
+                resolve(event);
+            };
+        });
+    }
+    close() {
+        if (this.isOpen()) {
+            this.events.process(IndexdbStatus.CONNECT_CLOSE);
+            this.connect.close();
+            this.events.close.call(this, this.connect);
+            this.connect = null;
+        }
+    }
+    createTable(tab) {
+        let table = tab;
+        if (_instance(tab, String)) {
+            table = { name: tab };
+        }
+        return new Table(table, this);
+    }
+    dropTable(tableName) {
+        return this.connect.deleteObjectStore(tableName);
+    }
+    table(tableName) {
+        if (!this.exists(tableName)) {
+            throw new Error(`table ${tableName} not exists!`);
+        }
+        return new Table({ name: tableName }, this);
+    }
+    exists(table) {
+        const tables = this.tables();
+        return tables && tables.contains(table);
+    }
+    tables() {
+        return this.connect['objectStoreNames'];
+    }
+}

package/lib/Driver.d.ts

@@ -0,0 +1,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;
+    selectByKey(table: string, key: any): any;
+    count(table: string, keyRange?: KeyRange): any;
+    update(table: string, modify: any, where: any): Promise<unknown> | undefined;
+    delete(table: string, key: any): void;
+    truncate(table: string): void;
+}
+export default Driver;

package/lib/Driver.js

@@ -0,0 +1,25 @@
+import Database from "./Database";
+class Driver extends Database {
+    insert(table, data) {
+        return this.table(table).insert(data);
+    }
+    select(table, keyRange, limit) {
+        return this.table(table).query(keyRange, limit);
+    }
+    selectByKey(table, key) {
+        return this.table(table).queryByKey(key);
+    }
+    count(table, keyRange) {
+        return this.table(table).count(keyRange);
+    }
+    update(table, modify, where) {
+        return this.table(table).update(modify, where);
+    }
+    delete(table, key) {
+        return this.table(table).delete(key);
+    }
+    truncate(table) {
+        return this.table(table).clear();
+    }
+}
+export default Driver;

package/lib/Table.d.ts

@@ -0,0 +1,30 @@
+import { KeyRange, CursorDirection } from "./Const";
+import TableIndex from "./TableIndex";
+import Database from "./Database";
+export default class Table {
+    readonly name: string;
+    readonly primaryKey: string;
+    readonly autoIncrement: boolean;
+    readonly indexes: Array<TableIndex>;
+    readonly database: Database;
+    constructor({ name, primaryKey, autoIncrement, indexes, data }: {
+        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;
+    delete(key: any): void;
+    clear(): void;
+    dropIndex(name: string): void;
+    keys(keyRange?: KeyRange, limit?: number): any;
+    count(keyRange?: KeyRange): any;
+    query(keyRange?: KeyRange, limit?: number): any;
+    queryByKey(key: any): any;
+    fetch(keyRange?: KeyRange, direction?: CursorDirection): Promise<unknown>;
+    queryByIndex(name: string, key: any): any;
+    deplete(direction?: any): Promise<unknown>;
+    multiple(indexName: string, each: Function, keyRange?: KeyRange, cursorDirection?: CursorDirection): Promise<unknown>;
+}

package/lib/Table.js

@@ -0,0 +1,154 @@
+import { _copy, _instance } from "./Utils";
+import { CursorDirection, TransactionMode } from "./Const";
+const _getObjectStore = (table, mode = TransactionMode.READ_ONLY) => {
+    const connect = table.database.connect;
+    const trans = connect.transaction(table.name, mode);
+    trans.oncomplete = (e) => console.debug(e);
+    trans.onerror = (e) => console.debug(e);
+    return trans.objectStore(table.name);
+};
+const _request = (request, success) => {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = (e) => {
+            !success ? resolve(e.target.result) : success(e.target.result, resolve);
+        };
+        request.onerror = (e) => {
+            reject(e.target.error);
+        };
+    });
+};
+export default class Table {
+    constructor({ name = '', primaryKey = 'id', autoIncrement = true, indexes = [], data = [] }, database) {
+        this.primaryKey = "id";
+        this.autoIncrement = false;
+        this.indexes = [];
+        this.name = name;
+        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));
+        }
+    }
+    insert(data) {
+        const arr = _instance(data, Array) ? data : [data];
+        const store = _getObjectStore(this, TransactionMode.READ_WRITE);
+        return new Promise((resolve) => {
+            let results = [];
+            arr.forEach((item, index) => {
+                _request(store.add(item)).then((rs) => {
+                    results.push(rs);
+                    if (index + 1 === arr.length)
+                        resolve(results);
+                });
+            });
+        });
+    }
+    update(modify, where) {
+        const store = _getObjectStore(this, TransactionMode.READ_WRITE);
+        if (!where) {
+            _request(store.put(modify));
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                _request(store.getAll(where)).then((rs) => {
+                    rs = _instance(rs, Array) ? rs : [rs];
+                    let rows = [];
+                    rs.forEach((item, index) => {
+                        _request(store.put(_copy(modify, item))).then((r) => {
+                            rows.push(r);
+                            if (index + 1 === rs.length) {
+                                resolve(rows);
+                            }
+                        });
+                    });
+                }).catch((err) => reject(err));
+            });
+        }
+    }
+    delete(key) {
+        _request(_getObjectStore(this, TransactionMode.READ_WRITE).delete(key));
+    }
+    clear() {
+        _request(_getObjectStore(this, TransactionMode.READ_WRITE).clear());
+    }
+    dropIndex(name) {
+        _getObjectStore(this, TransactionMode.READ_WRITE).deleteIndex(name);
+    }
+    keys(keyRange, limit) {
+        const store = _getObjectStore(this);
+        const request = store.getAllKeys(keyRange, limit);
+        return _request(request);
+    }
+    count(keyRange) {
+        const request = _getObjectStore(this).count(keyRange);
+        return _request(request);
+    }
+    query(keyRange, limit) {
+        const request = _getObjectStore(this).getAll(keyRange, limit);
+        return _request(request);
+    }
+    queryByKey(key) {
+        const request = _getObjectStore(this).get(key);
+        return _request(request);
+    }
+    fetch(keyRange, direction) {
+        const store = _getObjectStore(this);
+        const request = store.openCursor(null, direction);
+        return new Promise((resolve, reject) => {
+            let rows = [];
+            _request(request, (cursor) => {
+                if (!cursor) {
+                    resolve(rows);
+                    return;
+                }
+                rows.push(cursor.value);
+                cursor.continue();
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    queryByIndex(name, key) {
+        const store = _getObjectStore(this);
+        const index = store.index(name);
+        return _request(index.getAll(key));
+    }
+    deplete(direction = CursorDirection.NEXT) {
+        const store = _getObjectStore(this, TransactionMode.READ_WRITE);
+        const request = store.openCursor(null, direction);
+        return new Promise((resolve, reject) => {
+            let rows = [];
+            _request(request, (cursor) => {
+                if (!cursor) {
+                    resolve(rows);
+                    return;
+                }
+                rows.push(cursor.value);
+                cursor.continue();
+                store.delete(cursor.key);
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    multiple(indexName, each, keyRange, cursorDirection) {
+        const store = _getObjectStore(this);
+        const index = store.index(indexName);
+        const request = index.openCursor(keyRange, cursorDirection || CursorDirection.NEXT);
+        return new Promise((resolve, reject) => {
+            let rows = [];
+            _request(request, (cursor) => {
+                if (!cursor) {
+                    resolve(rows);
+                }
+                rows.push(cursor.value);
+                cursor.continue();
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+}

package/lib/TableIndex.d.ts

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

package/lib/TableIndex.js

@@ -0,0 +1,10 @@
+export default class TableIndex {
+    constructor(name, column, unique, multiEntry) {
+        this.unique = false;
+        this.multiEntry = false;
+        this.name = name;
+        this.column = column;
+        this.unique = !!unique;
+        this.multiEntry = !!multiEntry;
+    }
+}

package/lib/Utils.d.ts

@@ -0,0 +1,2 @@
+export declare function _instance(example: any, type: any): boolean;
+export declare function _copy(src: any, target: any): any;

package/lib/Utils.js

@@ -0,0 +1,19 @@
+export function _instance(example, type) {
+    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, target) {
+    if (!target)
+        return src;
+    for (let prop in src) {
+        target[prop] = src[prop];
+    }
+    return target;
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import { IndexdbStatus, TransactionMode, CursorDirection, KeyRange } from "./Const";
+import Driver from "./Driver";
+import Database from "./Database";
+import Table from "./Table";
+import TableIndex from "./TableIndex";
+export { IndexdbStatus, TransactionMode, CursorDirection, KeyRange, Database, TableIndex, Table };
+export default Driver;

package/lib/index.js

@@ -0,0 +1,7 @@
+import { IndexdbStatus, TransactionMode, CursorDirection, KeyRange } from "./Const";
+import Driver from "./Driver";
+import Database from "./Database";
+import Table from "./Table";
+import TableIndex from "./TableIndex";
+export { IndexdbStatus, TransactionMode, CursorDirection, KeyRange, Database, TableIndex, Table };
+export default Driver;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "xdriver",
+  "version": "1.0.01",
+  "description": "xdriver",
+  "main": "./lib/index",
+  "files": [
+    "lib/"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "build0": "tsc && babel lib --out-dir dist && cd lib && del *.js*",
+    "build-test": "tsc &&  webpack --mode production"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/xxx/indexdb.git"
+  },
+  "keywords": [
+    "storage"
+  ],
+  "author": "xs",
+  "license": "ISC",
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-preset-env": "^1.7.0",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-stage-2": "^6.24.1",
+    "webpack": "^5.64.2",
+    "webpack-cli": "^4.9.1",
+    "uglifyjs-webpack-plugin": "^2.2.0"
+  }
+}