query-core 0.1.8 → 0.1.12

package/src/services.ts

@@ -2,7 +2,7 @@ import {attributes, buildToDelete, buildToInsert, buildToUpdate, exist, metadata
 import {Attribute, Attributes, Statement, StringMap} from './metadata';
 import {SearchResult} from './search';
 
-export interface SearchModel {
+export interface Filter {
   fields?: string[];
   sort?: string;
   q?: string;
@@ -15,10 +15,11 @@ export class SqlLoader<T, ID> {
   constructor(public table: string,
     public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<T[]>,
     attrs: Attributes|string[],
-    protected param: (i: number) => string,
-    protected fromDB?: (v: T) => T) {
+    public param: (i: number) => string,
+    public fromDB?: (v: T) => T) {
     if (Array.isArray(attrs)) {
       this.primaryKeys = attributes(attrs);
+      this.attributes = {} as any;
     } else {
       const m = metadata(attrs);
       this.attributes = attrs;
@@ -26,27 +27,33 @@ export class SqlLoader<T, ID> {
       this.map = m.map;
       this.bools = m.bools;
     }
-    this.metadata = this.metadata.bind(this);
+    if (this.metadata) {
+      this.metadata = this.metadata.bind(this);
+    }
     this.all = this.all.bind(this);
     this.load = this.load.bind(this);
     this.exist = this.exist.bind(this);
   }
-  metadata(): Attributes {
+  metadata?(): Attributes|undefined {
     return this.attributes;
   }
   all(): Promise<T[]> {
     const sql = `select * from ${this.table}`;
     return this.query(sql, [], this.map);
   }
-  load(id: ID, ctx?: any): Promise<T> {
+  load(id: ID, ctx?: any): Promise<T|null> {
     const stmt = select<ID>(id, this.table, this.primaryKeys, this.param);
-    if (this.fromDB) {
+    if (!stmt) {
+      throw new Error('cannot build query by id');
+    }
+    const fn = this.fromDB;
+    if (fn) {
       return this.query(stmt.query, stmt.params, this.map, ctx).then(res => {
         if (!res || res.length === 0) {
           return null;
         } else {
           const obj = res[0];
-          return this.fromDB(obj);
+          return fn(obj);
         }
       });
     } else {
@@ -54,12 +61,15 @@ export class SqlLoader<T, ID> {
     }
   }
   exist(id: ID, ctx?: any): Promise<boolean> {
-    const field = (this.primaryKeys[0].field ? this.primaryKeys[0].field : this.primaryKeys[0].name);
+    const field = (this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name);
     const stmt = exist<ID>(id, this.table, this.primaryKeys, this.param, field);
+    if (!stmt) {
+      throw new Error('cannot build query by id');
+    }
     return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then(res => (!res || res.length === 0) ? false : true);
   }
 }
-export class SqlSearchLoader<T, ID, S extends SearchModel> extends SqlLoader<T, ID> {
+export class SqlSearchLoader<T, ID, S extends Filter> extends SqlLoader<T, ID> {
   constructor(
       protected find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
       table: string,
@@ -75,32 +85,23 @@ export class SqlSearchLoader<T, ID, S extends SearchModel> extends SqlLoader<T,
   }
 }
 export interface Manager {
+  param(i: number): string;
   exec(sql: string, args?: any[], ctx?: any): Promise<number>;
   execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
-  query<T>(sql: string, args?: any[], m?: StringMap, fields?: string[], ctx?: any): Promise<T[]>;
-}
-export function createSqlWriter<T, ID>(table: string,
-    manager: Manager,
-    attrs: Attributes,
-    buildParam: (i: number) => string,
-    toDB?: (v: T) => T,
-    fromDB?: (v: T) => T) {
-  const writer = new SqlWriter<T, ID>(table, manager.query, manager.exec, attrs, buildParam, toDB, fromDB, manager.execBatch);
-  return writer;
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
 }
-
 export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
   version?: string;
-  constructor(table: string,
-    query: (sql: string, args?: any[], m?: StringMap, ctx?: any) => Promise<T[]>,
-    public exec: (sql: string, args?: any[], ctx?: any) => Promise<number>,
+  exec: (sql: string, args?: any[], ctx?: any) => Promise<number>;
+  execBatch: (statements: Statement[], firstSuccess?: boolean, ctx?: any) => Promise<number>;
+  constructor(manager: Manager, table: string,
     attrs: Attributes,
-    buildParam: (i: number) => string,
-    protected toDB?: (v: T) => T,
-    fromDB?: (v: T) => T,
-    public execBatch?: (statements: Statement[], firstSuccess?: boolean, ctx?: any) => Promise<number>) {
-    super(table, query, attrs, buildParam, fromDB);
+    public toDB?: (v: T) => T,
+    fromDB?: (v: T) => T) {
+    super(table, manager.query, attrs, manager.param, fromDB);
     const x = version(attrs);
+    this.exec = manager.exec;
+    this.execBatch = manager.execBatch;
     if (x) {
       this.version = x.name;
     }
@@ -151,32 +152,18 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
     }
   }
 }
-export class SqlSearchWriter<T, ID, S extends SearchModel> extends SqlWriter<T, ID> {
+export class SqlSearchWriter<T, ID, S extends Filter> extends SqlWriter<T, ID> {
   constructor(
       protected find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
+      manager: Manager,
       table: string,
-      query: (sql: string, args?: any[], m?: StringMap, ctx?: any) => Promise<T[]>,
-      exec: (sql: string, args?: any[], ctx?: any) => Promise<number>,
       attrs: Attributes,
-      buildParam: (i: number) => string,
       toDB?: (v: T) => T,
-      fromDB?: (v: T) => T,
-      execBatch?: (statements: Statement[], firstSuccess?: boolean, ctx?: any) => Promise<number>) {
-    super(table, query, exec, attrs, buildParam, toDB, fromDB, execBatch);
+      fromDB?: (v: T) => T) {
+    super(manager, table, attrs, toDB, fromDB);
     this.search = this.search.bind(this);
   }
   search(s: S, limit?: number, offset?: number|string, fields?: string[]): Promise<SearchResult<T>> {
     return this.find(s, limit, offset, fields);
   }
 }
-export function createSqlSearchWriter<T, ID, S extends SearchModel>(
-  find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
-  table: string,
-  manager: Manager,
-  attrs: Attributes,
-  buildParam: (i: number) => string,
-  toDB?: (v: T) => T,
-  fromDB?: (v: T) => T) {
-const writer = new SqlSearchWriter<T, ID, S>(find, table, manager.query, manager.exec, attrs, buildParam, toDB, fromDB, manager.execBatch);
-return writer;
-}

package/tsconfig.json

@@ -6,6 +6,7 @@
     "outDir": "./lib",
     "module": "commonjs",
     "moduleResolution": "node",
+    "strict": true,
     "pretty": true,
     "sourceMap": false,
     "declaration": false,