xdriver 2.0.8 → 2.0.10

package/lib/database.d.ts

@@ -1,5 +1,6 @@
 import Connection from "./connection";
-import { Row, Pagination, RowPacket } from "./table";
+import { Pagination, Row, RowPacket } from "./table";
+import Mapper from "./mapper";
 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>>;
@@ -9,10 +10,11 @@ export default class Database extends Connection {
     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[]>;
+    delete(table: string, key: IDBValidKey | IDBKeyRange): Promise<Row[]>;
     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>>;
+    getMapper<R extends Row>(tableName: string): Mapper<R>;
 }

package/lib/database.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import Connection from "./connection";
+import Mapper from "./mapper";
 export default class Database extends Connection {
     query(table, query, count = 1000) {
         return this.table(table).query(query, count);
@@ -59,4 +60,7 @@ export default class Database extends Connection {
             return this.table(table).paginate(pageNo, pageSize, key, indexName);
         });
     }
+    getMapper(tableName) {
+        return new Mapper(this.table(tableName));
+    }
 }

package/lib/index.d.ts

@@ -1,9 +1,10 @@
 import { IndexdbStatus, KeyRange } from "./const";
 import Database from "./database";
 import Connection from "./connection";
-import Table, { TableMeta } from "./table";
+import Table, { Row, TableMeta } from "./table";
 import { Logger } from "./com";
-declare class Driver {
+import Mapper from "./mapper";
+export default class Driver {
     private readonly name;
     private version;
     private readonly tables;
@@ -12,11 +13,18 @@ declare class Driver {
     private hasChange;
     connect(version?: number): Promise<Database>;
 }
-export { IndexdbStatus, KeyRange, Connection, Table, Logger, Driver };
+export { IndexdbStatus, KeyRange, Connection, Table, Logger, Mapper, Row };
+export interface TableDeclare<T extends Row> {
+    name: string;
+    primaryKey?: keyof T | Array<keyof T>;
+    autoIncrement?: boolean;
+    rows?: Array<T>;
+    indexes?: Array<{
+        name: string;
+        column: Array<keyof T> | keyof T;
+        unique?: boolean;
+        multiEntry?: boolean;
+    }>;
+}
 export declare function getConnect(name: string, tables: Array<TableMeta>, version?: number): Promise<Database>;
-export declare function open(name: string, version?: number): {
-    define: (tables: Array<TableMeta>) => {
-        connect: (version?: number) => Promise<Database>;
-    };
-};
-export default Driver;
+export declare function openConnect<T extends Row>(name: string, tables: Array<TableDeclare<T>>, version?: number): Promise<Database>;

package/lib/index.js

@@ -12,8 +12,9 @@ import Database from "./database";
 import Connection from "./connection";
 import Table from "./table";
 import { Logger } from "./com";
+import Mapper from "./mapper";
 const logger = Logger.getLogger("Driver");
-class Driver {
+export default class Driver {
     constructor(name, version = 0) {
         this.tables = [];
         this.name = name;
@@ -136,21 +137,14 @@ class Driver {
         });
     }
 }
-export { IndexdbStatus, KeyRange, Connection, Table, Logger, Driver };
+export { IndexdbStatus, KeyRange, Connection, Table, Logger, Mapper };
 export function getConnect(name, tables, version = 0) {
     let driver = new Driver(name, version);
     driver.defineTables(...tables);
     return driver.connect();
 }
-export function open(name, version = 0) {
+export function openConnect(name, tables, version = 0) {
     let driver = new Driver(name, version);
-    return {
-        define: (tables) => {
-            driver.defineTables(...tables);
-            return {
-                connect: (version) => driver.connect(version),
-            };
-        }
-    };
+    driver.defineTables(...tables.map(t => t));
+    return driver.connect();
 }
-export default Driver;

package/lib/mapper.d.ts

@@ -0,0 +1,19 @@
+import Table, { Pagination, Row, RowPacket } from "./table";
+export default class Mapper<T extends Row> {
+    private table;
+    constructor(table: Table);
+    truncate(): Promise<void>;
+    count(key?: IDBValidKey | IDBKeyRange): Promise<number>;
+    insert(data: T | Array<T>): Promise<IDBValidKey[]>;
+    update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey>;
+    query(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>>;
+    queryById(id: any | Array<any>, indexName?: string): Promise<T | Array<T>>;
+    delete(key: IDBValidKey | IDBKeyRange): Promise<Array<T>>;
+    queryByIndex(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>>;
+    queryByKey(key: IDBValidKey | IDBKeyRange): Promise<RowPacket<T>>;
+    scan(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection, indexName?: string): Promise<RowPacket<T>>;
+    select(key?: IDBValidKey | IDBKeyRange, count?: number, indexName?: string): Promise<RowPacket<T>>;
+    paginate<R extends Row>(pageNo?: number, pageSize?: number, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>>;
+    getPagination(pageSize?: number): Promise<Pagination<T>>;
+    getAll(): Promise<Array<T>>;
+}

package/lib/mapper.js

@@ -0,0 +1,47 @@
+export default class Mapper {
+    constructor(table) {
+        this.table = table;
+    }
+    truncate() {
+        return this.table.truncate();
+    }
+    count(key) {
+        return this.table.count(key);
+    }
+    insert(data) {
+        return this.table.insert(data);
+    }
+    update(modify, key) {
+        return this.table.update(modify, key);
+    }
+    query(key, count) {
+        return this.table.query(key, count);
+    }
+    queryById(id, indexName) {
+        return this.table.queryById(id, indexName);
+    }
+    delete(key) {
+        return this.table.delete(key);
+    }
+    queryByIndex(indexName, key, count) {
+        return this.table.queryByIndex(indexName, key, count);
+    }
+    queryByKey(key) {
+        return this.table.queryByKey(key);
+    }
+    scan(key, direction = 'next', indexName) {
+        return this.table.scan(key, direction, indexName);
+    }
+    select(key, count, indexName) {
+        return this.table.select(key, count, indexName);
+    }
+    paginate(pageNo = 1, pageSize = 10, key, indexName) {
+        return this.table.paginate(pageNo, pageSize, key, indexName);
+    }
+    getPagination(pageSize = 10) {
+        return this.table.getPagination(pageSize);
+    }
+    getAll() {
+        return this.table.getAllData();
+    }
+}

package/lib/table.d.ts

@@ -57,7 +57,7 @@ export default class Table implements ITable {
     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[]>;
+    delete<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<Array<R>>;
     truncate(): Promise<void>;
     dropIndex(name: string): void;
     keys(key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey[]>;

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/com.ts","../src/connection.ts","../src/const.ts","../src/database.ts","../src/index.ts","../src/table.ts"],"version":"5.9.3"}
+{"root":["../src/com.ts","../src/connection.ts","../src/const.ts","../src/database.ts","../src/index.ts","../src/mapper.ts","../src/table.ts"],"version":"5.9.3"}

package/package.json

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

package/src/database.ts

@@ -1,5 +1,6 @@
 import Connection from "./connection";
-import {Row, Pagination, RowPacket} from "./table";
+import {Pagination, Row, RowPacket} from "./table";
+import Mapper from "./mapper";
 
 export default class Database extends Connection {
 
@@ -138,4 +139,8 @@ export default class Database extends Connection {
     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)
     }
+
+    getMapper<R extends Row>(tableName: string):Mapper<R> {
+        return new Mapper<R>(this.table(tableName))
+    }
 }

package/src/index.ts

@@ -1,13 +1,13 @@
 import {IndexdbStatus, innerDB, KeyRange} from "./const";
 import Database from "./database";
 import Connection from "./connection";
-import Table, {TableMeta} from "./table";
+import Table, {Row, TableMeta} from "./table";
 import {Logger} from "./com";
-
+import Mapper from "./mapper";
 
 const logger = Logger.getLogger("Driver")
 
-class Driver {
+export default class Driver {
     private readonly name: string;
     private version: number;
     private readonly tables: Array<TableMeta> = [];
@@ -144,7 +144,20 @@ class Driver {
     }
 }
 
-export {IndexdbStatus, KeyRange, Connection, Table, Logger, Driver};
+export {IndexdbStatus, KeyRange, Connection, Table, Logger, Mapper, Row};
+
+export interface TableDeclare<T extends Row> {
+    name: string;
+    primaryKey?: keyof T | Array<keyof T>;
+    autoIncrement?: boolean;
+    rows?: Array<T>;
+    indexes?: Array<{
+        name: string;
+        column: Array<keyof T> | keyof T;
+        unique?: boolean;
+        multiEntry?: boolean;
+    }>;
+}
 
 export function getConnect(name: string, tables: Array<TableMeta>, version: number = 0) {
     let driver = new Driver(name, version);
@@ -152,16 +165,8 @@ export function getConnect(name: string, tables: Array<TableMeta>, version: numb
     return driver.connect();
 }
 
-export function open(name: string, version: number = 0) {
+export function openConnect<T extends Row>(name: string, tables: Array<TableDeclare<T>>, version: number = 0) {
     let driver = new Driver(name, version);
-    return {
-        define: (tables: Array<TableMeta>) => {
-            driver.defineTables(...tables);
-            return {
-                connect: (version?: number) => driver.connect(version),
-            }
-        }
-    }
-}
-
-export default Driver;
+    driver.defineTables(...tables.map(t => t as TableMeta));
+    return driver.connect();
+}

package/src/mapper.ts

@@ -0,0 +1,65 @@
+import Table, {Pagination, Row, RowPacket} from "./table";
+
+export default class Mapper<T extends Row> {
+    private table: Table;
+
+    constructor(table: Table) {
+        this.table = table;
+    }
+
+    truncate() {
+        return this.table.truncate();
+    }
+
+    count(key?: IDBValidKey | IDBKeyRange) {
+        return this.table.count(key);
+    }
+
+    insert(data: T | Array<T>) {
+        return this.table.insert(data);
+    }
+
+    update(modify: Row, key?: IDBValidKey | IDBKeyRange | null): Promise<IDBValidKey> {
+        return this.table.update(modify, key);
+    }
+
+    query(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>> {
+        return this.table.query(key, count);
+    }
+
+    queryById(id: any | Array<any>, indexName?: string): Promise<T | Array<T>> {
+        return this.table.queryById(id, indexName);
+    }
+
+    delete(key: IDBValidKey | IDBKeyRange): Promise<Array<T>> {
+        return this.table.delete(key);
+    }
+
+    queryByIndex(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<RowPacket<T>> {
+        return this.table.queryByIndex(indexName, key, count);
+    }
+
+    queryByKey(key: IDBValidKey | IDBKeyRange): Promise<RowPacket<T>> {
+        return this.table.queryByKey(key);
+    }
+
+    scan(key?: IDBValidKey | IDBKeyRange, direction: IDBCursorDirection = 'next', indexName?: string): Promise<RowPacket<T>> {
+        return this.table.scan(key, direction, indexName);
+    }
+
+    select(key?: IDBValidKey | IDBKeyRange, count?: number, indexName?: string): Promise<RowPacket<T>> {
+        return this.table.select(key, count, indexName);
+    }
+
+    paginate<R extends Row>(pageNo: number = 1, pageSize: number = 10, key?: IDBValidKey | IDBKeyRange, indexName?: string): Promise<RowPacket<R>> {
+        return this.table.paginate(pageNo, pageSize, key, indexName);
+    }
+
+    getPagination(pageSize: number = 10): Promise<Pagination<T>> {
+        return this.table.getPagination(pageSize);
+    }
+
+    getAll(): Promise<Array<T>> {
+        return this.table.getAllData();
+    }
+}

package/src/table.ts

@@ -350,7 +350,7 @@ export default class Table implements ITable{
      * 根据主键值删除
      * @param key
      */
-    async delete(key: IDBValidKey | IDBKeyRange) {
+    async delete<R extends Row>(key: IDBValidKey | IDBKeyRange): Promise<Array<R>> {
         if (!key) {
             return Promise.reject('key is required');
         }