query-core 0.1.8 → 0.1.9

package/src/client.ts

@@ -0,0 +1,202 @@
+import {buildToInsert, buildToInsertBatch, buildToUpdate, buildToUpdateBatch} from './build';
+import {handleResults} from './map';
+import {Attribute, Attributes, Statement, StringMap} from './metadata';
+
+export interface JStatement {
+  query: string;
+  params?: any[];
+  dates?: number[];
+}
+export interface Headers {
+  [key: string]: any;
+}
+export interface HttpOptionsService {
+  getHttpOptions(): { headers?: Headers };
+}
+export interface HttpRequest {
+  post<T>(url: string, obj: any, options?: {headers?: Headers}): Promise<T>;
+}
+export interface Proxy {
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>;
+  exec(sql: string, args?: any[]): Promise<number>;
+  execBatch(stmts: Statement[]): Promise<number>;
+  beginTransaction?(timeout?: number): Promise<string>;
+  commitTransaction?(tx: string): Promise<boolean>;
+  rollbackTransaction?(tx: string): Promise<boolean>;
+  queryWithTx?<T>(tx: string, commit: boolean, sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>;
+  execWithTx?(tx: string, commit: boolean, sql: string, args?: any[]): Promise<number>;
+  execBatchWithTx?(tx: string, commit: boolean, stmts: Statement[]): Promise<number>;
+  insert?<T>(table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number>;
+  update?<T>(table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number>;
+  insertBatch?<T>(table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, driver?: string): Promise<number>;
+  updateBatch?<T>(table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, notSkipInvalid?: boolean): Promise<number>;
+  insertWithTx?<T>(tx: string, commit: boolean, table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number>;
+  updateWithTx?<T>(tx: string, commit: boolean, table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number>;
+  insertBatchWithTx?<T>(tx: string, commit: boolean, table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, driver?: string): Promise<number>;
+  updateBatchWithTx?<T>(tx: string, commit: boolean, table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, notSkipInvalid?: boolean): Promise<number>;
+  save?<T>(table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number>;
+  saveBatch?<T>(table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, ver?: string): Promise<number>;
+}
+export function buildStatements(s: Statement[]): JStatement[] {
+  const d: JStatement[] = [];
+  if (!s || s.length === 0) {
+    return d;
+  }
+  for (const t of s) {
+    const dates = toDates(t.params);
+    const j: JStatement = {query: t.query, params: t.params, dates};
+    d.push(j);
+  }
+  return d;
+}
+export function toDates(args?: any[]): number[] {
+  const d: number[] = [];
+  if (!args || args.length === 0) {
+    return d;
+  }
+  const l = args.length;
+  for (let i = 0; i < l; i++) {
+    if (args[i] && args[i] instanceof Date) {
+      d.push(i);
+    }
+  }
+  return d;
+}
+export class ProxyClient {
+  constructor(protected httpRequest: HttpRequest, protected url: string) {
+    this.query = this.query.bind(this);
+    this.exec = this.exec.bind(this);
+    this.execBatch = this.execBatch.bind(this);
+
+    this.insert = this.insert.bind(this);
+    this.update = this.update.bind(this);
+    this.insertBatch = this.insertBatch.bind(this);
+    this.updateBatch = this.updateBatch.bind(this);
+    this.insertWithTx = this.insertWithTx.bind(this);
+    this.updateWithTx = this.updateWithTx.bind(this);
+    this.insertBatchWithTx = this.insertBatchWithTx.bind(this);
+    this.updateBatchWithTx = this.updateBatchWithTx.bind(this);
+
+    this.beginTransaction = this.beginTransaction.bind(this);
+    this.commitTransaction = this.commitTransaction.bind(this);
+    this.rollbackTransaction = this.rollbackTransaction.bind(this);
+    this.queryWithTx = this.queryWithTx.bind(this);
+    this.execWithTx = this.execWithTx.bind(this);
+    this.execBatchWithTx = this.execBatchWithTx.bind(this);
+  }
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]> {
+    const dates = toDates(args);
+    const j: JStatement = {query: sql, params: args, dates};
+    if (m || bools) {
+      return this.httpRequest.post<T[]>(this.url + '/query', j).then(r => handleResults(r, m, bools));
+    } else {
+      return this.httpRequest.post<T[]>(this.url + '/query', j);
+    }
+  }
+  exec(sql: string, args?: any[]): Promise<number> {
+    const dates = toDates(args);
+    const j: JStatement = {query: sql, params: args, dates};
+    return this.httpRequest.post<number>(this.url + '/exec', j);
+  }
+  execBatch(stmts: Statement[]): Promise<number> {
+    const d = buildStatements(stmts);
+    return this.httpRequest.post<number>(this.url + '/exec-batch', d);
+  }
+
+  beginTransaction(timeout?: number): Promise<string> {
+    const st = (timeout && timeout > 0 ? '?timeout=' + timeout : '');
+    return this.httpRequest.post<string>(this.url + '/begin' + st, '');
+  }
+  commitTransaction(tx: string): Promise<boolean> {
+    return this.httpRequest.post<boolean>(this.url + '/end?tx=' + tx, '');
+  }
+  rollbackTransaction(tx: string): Promise<boolean> {
+    return this.httpRequest.post<boolean>(this.url + '/end?roleback=true&tx=' + tx, '');
+  }
+  queryWithTx<T>(tx: string, commit: boolean, sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]> {
+    const dates = toDates(args);
+    const j: JStatement = {query: sql, params: args, dates};
+    const sc = (commit ? '&commit=true' : '');
+    if (m || bools) {
+      return this.httpRequest.post<T[]>(this.url + '/query?tx=' + tx + sc, j).then(r => handleResults(r, m, bools));
+    } else {
+      return this.httpRequest.post<T[]>(this.url + '/query?tx=' + tx + sc, j);
+    }
+  }
+  execWithTx(tx: string, commit: boolean, sql: string, args?: any[]): Promise<number> {
+    const dates = toDates(args);
+    const j: JStatement = {query: sql, params: args, dates};
+    const sc = (commit ? '&commit=true' : '');
+    return this.httpRequest.post<number>(this.url + '/exec?tx=' + tx + sc, j);
+  }
+  execBatchWithTx(tx: string, commit: boolean, stmts: Statement[]): Promise<number> {
+    const d = buildStatements(stmts);
+    const sc = (commit ? '&commit=true' : '');
+    return this.httpRequest.post<number>(this.url + '/exec-batch?tx=' + tx + sc, d);
+  }
+
+  insert<T>(table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number> {
+    const s = buildToInsert(obj, table, attrs, buildParam, ver);
+    if (s) {
+      return this.exec(s.query, s.params);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  update<T>(table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number> {
+    const s = buildToUpdate(obj, table, attrs, buildParam, ver);
+    if (s) {
+      return this.exec(s.query, s.params);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  insertBatch<T>(table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, driver?: string): Promise<number> {
+    const s = buildToInsertBatch(objs, table, attrs, buildParam);
+    if (s) {
+      return this.exec(s.query, s.params);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  updateBatch<T>(table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, notSkipInvalid?: boolean): Promise<number> {
+    const s = buildToUpdateBatch(objs, table, attrs, buildParam, notSkipInvalid);
+    if (s && s.length > 0) {
+      return this.execBatch(s);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  insertWithTx<T>(tx: string, commit: boolean, table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number> {
+    const s = buildToInsert(obj, table, attrs, buildParam, ver);
+    if (s) {
+      return this.execWithTx(tx, commit, s.query, s.params);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  updateWithTx<T>(tx: string, commit: boolean, table: string, attrs: Attributes, obj: T, buildParam: (i: number) => string, ver?: string): Promise<number> {
+    const s = buildToUpdate(obj, table, attrs, buildParam, ver);
+    if (s) {
+      return this.execWithTx(tx, commit, s.query, s.params);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  insertBatchWithTx<T>(tx: string, commit: boolean, table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, driver?: string): Promise<number> {
+    const s = buildToInsertBatch(objs, table, attrs, buildParam);
+    if (s) {
+      return this.execWithTx(tx, commit, s.query, s.params);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+  updateBatchWithTx<T>(tx: string, commit: boolean, table: string, attrs: Attributes, objs: T[], buildParam: (i: number) => string, notSkipInvalid?: boolean): Promise<number> {
+    const s = buildToUpdateBatch(objs, table, attrs, buildParam, notSkipInvalid);
+    if (s && s.length > 0) {
+      return this.execBatchWithTx(tx, commit, s);
+    } else {
+      return Promise.resolve(-1);
+    }
+  }
+}

package/src/index.ts

@@ -6,12 +6,20 @@ export {SqlLoader as SqlLoadService};
 export {SqlWriter as SqlGenericService};
 export {SqlSearchLoader as ViewSearchRepository};
 export {SqlSearchLoader as ViewSearchService};
+export {SqlSearchLoader as SearchRepository};
+export {SqlSearchLoader as SearchService};
 export {SqlSearchWriter as GenericSearchRepository};
 export {SqlSearchWriter as GenericSearchService};
+export {SqlSearchWriter as SqlRepository};
+export {SqlSearchWriter as SqlService};
+export {SqlSearchWriter as Repository};
+export {SqlSearchWriter as Service};
 export {createSqlWriter as createGenericRepository};
 export {createSqlWriter as createGenericService};
 export {createSqlSearchWriter as createGenericSearchRepository};
 export {createSqlSearchWriter as createGenericSearchService};
+export {createSqlSearchWriter as createRepository};
+export {createSqlSearchWriter as createService};
 
 export * from './metadata';
 export * from './build';
@@ -20,7 +28,21 @@ export * from './batch';
 export * from './query';
 export * from './search';
 export * from './SearchBuilder';
+export * from './client';
 
+export interface Config {
+  connectString?: string | undefined;
+  host?: string | undefined;
+  port?: number;
+  server?: string | undefined;
+  database?: string | undefined;
+  user?: string | undefined;
+  password?: string | undefined;
+  multipleStatements?: boolean | undefined;
+  max?: number | undefined;
+  min?: number | undefined;
+  idleTimeoutMillis?: number | undefined;
+}
 // tslint:disable-next-line:class-name
 export class resource {
   static string?: boolean;
@@ -63,43 +85,6 @@ export function toArray(arr: any[]): any[] {
   }
   return p;
 }
-export function handleResults<T>(r: T[], m?: StringMap, bools?: Attribute[]): T[] {
-  if (m) {
-    const res = mapArray(r, m);
-    if (bools && bools.length > 0) {
-      return handleBool(res, bools);
-    } else {
-      return res;
-    }
-  } else {
-    if (bools && bools.length > 0) {
-      return handleBool(r, bools);
-    } else {
-      return r;
-    }
-  }
-}
-export function handleBool<T>(objs: T[], bools: Attribute[]): T[] {
-  if (!bools || bools.length === 0 || !objs) {
-    return objs;
-  }
-  for (const obj of objs) {
-    for (const field of bools) {
-      const value = obj[field.name];
-      if (value != null && value !== undefined) {
-        const b = field.true;
-        if (b == null || b === undefined) {
-          // tslint:disable-next-line:triple-equals
-          obj[field.name] = ('1' == value || 'T' == value || 'Y' == value);
-        } else {
-          // tslint:disable-next-line:triple-equals
-          obj[field.name] = (value == b ? true : false);
-        }
-      }
-    }
-  }
-  return objs;
-}
 export function map<T>(obj: T, m?: StringMap): any {
   if (!m) {
     return obj;
@@ -115,32 +100,7 @@ export function map<T>(obj: T, m?: StringMap): any {
     if (!k0) {
       k0 = key;
     }
-    obj2[k0] = obj[key];
+    obj2[k0] = (obj as any)[key];
   }
   return obj2;
 }
-export function mapArray<T>(results: T[], m?: StringMap): T[] {
-  if (!m) {
-    return results;
-  }
-  const mkeys = Object.keys(m);
-  if (mkeys.length === 0) {
-    return results;
-  }
-  const objs = [];
-  const length = results.length;
-  for (let i = 0; i < length; i++) {
-    const obj = results[i];
-    const obj2: any = {};
-    const keys = Object.keys(obj);
-    for (const key of keys) {
-      let k0 = m[key];
-      if (!k0) {
-        k0 = key;
-      }
-      obj2[k0] = (obj as any)[key];
-    }
-    objs.push(obj2);
-  }
-  return objs;
-}

package/src/map.ts

@@ -0,0 +1,67 @@
+import {Attribute, StringMap} from './metadata';
+
+export function mapArray<T>(results: T[], m?: StringMap): T[] {
+  if (!m) {
+    return results;
+  }
+  const mkeys = Object.keys(m);
+  if (mkeys.length === 0) {
+    return results;
+  }
+  const objs = [];
+  const length = results.length;
+  for (let i = 0; i < length; i++) {
+    const obj = results[i];
+    const obj2: any = {};
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+      let k0 = m[key];
+      if (!k0) {
+        k0 = key;
+      }
+      obj2[k0] = (obj as any)[key];
+    }
+    objs.push(obj2);
+  }
+  return objs;
+}
+export function handleResults<T>(r: T[], m?: StringMap, bools?: Attribute[]): T[] {
+  if (m) {
+    const res = mapArray(r, m);
+    if (bools && bools.length > 0) {
+      return handleBool(res, bools);
+    } else {
+      return res;
+    }
+  } else {
+    if (bools && bools.length > 0) {
+      return handleBool(r, bools);
+    } else {
+      return r;
+    }
+  }
+}
+export function handleBool<T>(objs: T[], bools: Attribute[]): T[] {
+  if (!bools || bools.length === 0 || !objs) {
+    return objs;
+  }
+  for (const obj of objs) {
+    const o: any = obj;
+    for (const field of bools) {
+      if (field.name) {
+        const v = o[field.name];
+        if (typeof v !== 'boolean' && v != null && v !== undefined) {
+          const b = field.true;
+          if (b == null || b === undefined) {
+            // tslint:disable-next-line:triple-equals
+            o[field.name] = ('true' == v || '1' == v || 't' == v || 'y' == v || 'on' == v);
+          } else {
+            // tslint:disable-next-line:triple-equals
+            o[field.name] = (v == b ? true : false);
+          }
+        }
+      }
+    }
+  }
+  return objs;
+}

package/src/query.ts

@@ -3,7 +3,7 @@ import {Attribute, Attributes, Statement, StringMap} from './metadata';
 
 export type LikeType = 'like' | 'ilike';
 
-export function buildSort(sort: string, map?: Attributes|StringMap): string {
+export function buildSort(sort?: string, map?: Attributes|StringMap): string {
   if (!sort || sort.length === 0) {
     return '';
   }
@@ -52,7 +52,11 @@ export function buildOracleParam(i: number): string {
 export function buildDollarParam(i: number): string {
   return '$' + i;
 }
-export function buildQuery<S>(s: S, bparam: LikeType|((i: number ) => string), table?: string, attrs?: Attributes, sort?: string, fields?: string[], sq?: string, strExcluding?: string, buildSort3?: (sort: string, map?: Attributes|StringMap) => string): Statement {
+export function buildQuery<S>(filter: S, bparam: LikeType|((i: number ) => string), table?: string, attrs?: Attributes, sort?: string, fields?: string[], sq?: string, strExcluding?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string): Statement|undefined {
+  if (!table || !attrs) {
+    return undefined;
+  }
+  const s: any = filter;
   let like = 'like';
   let param: (i: number ) => string;
   if (typeof bparam === 'string') {
@@ -67,8 +71,8 @@ export function buildQuery<S>(s: S, bparam: LikeType|((i: number ) => string), t
     like = 'like';
   }
   const filters: string[] = [];
-  let q: string;
-  let excluding: string[]|number[];
+  let q: string|undefined;
+  let excluding: string[]|number[]|undefined;
   const args: any[] = [];
   if (sq && sq.length > 0) {
     q = s[sq];
@@ -220,7 +224,7 @@ export function buildQuery<S>(s: S, bparam: LikeType|((i: number ) => string), t
           qfilters.push(`${field} ${like} ${param(i++)}`);
           args.push('%' + q + '%');
         }
-        c.push(buildQ(field, attr.match, q));
+        c.push(buildQ(field, q, attr.match));
       }
     }
     if (qfilters.length > 0) {
@@ -238,7 +242,7 @@ export function buildQuery<S>(s: S, bparam: LikeType|((i: number ) => string), t
     return { query: sql, params: args };
   }
 }
-export function getId(attrs: Attributes): string {
+export function getId(attrs: Attributes): string|undefined {
   const qkeys = Object.keys(attrs);
   for (const key of qkeys) {
     const attr = attrs[key];
@@ -270,8 +274,8 @@ export function buildFieldsByAttributes(attrs: Attributes, fields?: string[]): s
 export function isEmpty(s: string): boolean {
   return !(s && s.length > 0);
 }
-export function buildQ(field: string, match: string, q: string): any {
-  const o = {};
+export function buildQ(field: string, q: string, match?: string): any {
+  const o: any = {};
   if (match === 'equal') {
     o[field] = q;
   } else if (match === 'prefix') {
@@ -293,7 +297,7 @@ export function buildMatch(v: string, match: string): string|RegExp {
 export function isDateRange<T>(obj: T): boolean {
   const keys: string[] = Object.keys(obj);
   for (const key of keys) {
-    const v = obj[key];
+    const v = (obj as any)[key];
     if (!(v instanceof Date)) {
       return false;
     }
@@ -303,7 +307,7 @@ export function isDateRange<T>(obj: T): boolean {
 export function isNumberRange<T>(obj: T): boolean {
   const keys: string[] = Object.keys(obj);
   for (const key of keys) {
-    const v = obj[key];
+    const v = (obj as any)[key];
     if (typeof v !== 'number') {
       return false;
     }

package/src/search.ts

@@ -4,8 +4,8 @@ export interface SearchResult<T> {
   list: T[];
   total?: number;
 }
-export function buildFromQuery<T>(query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, sql: string, params: any[], limit: number, offset: number, mp?: StringMap, bools?: Attribute[], provider?: string, totalCol?: string): Promise<SearchResult<T>> {
-  if (limit <= 0) {
+export function buildFromQuery<T>(query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, sql: string, params?: any[], limit?: number, offset?: number, mp?: StringMap, bools?: Attribute[], provider?: string, totalCol?: string): Promise<SearchResult<T>> {
+  if (!limit || limit <= 0) {
     return query(sql, params, mp, bools).then(list => {
       const total = (list ? list.length : undefined);
       return {list, total};
@@ -27,7 +27,7 @@ export function buildFromQuery<T>(query: (sql: string, args?: any[], m?: StringM
         } else {
           const r0 = r[0];
           const keys = Object.keys(r0);
-          return r0[keys[0]] as number;
+          return (r0 as any)[keys[0]] as number;
         }
       });
       return Promise.all([resultPromise, countPromise]).then(r => {
@@ -37,7 +37,7 @@ export function buildFromQuery<T>(query: (sql: string, args?: any[], m?: StringM
     }
   }
 }
-export function queryAndCount<T>(query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, sql: string, params: any[], total: string, mp?: StringMap, bools?: Attribute[]): Promise<SearchResult<T>> {
+export function queryAndCount<T>(query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, sql: string, params: any[]|undefined, total: string, mp?: StringMap, bools?: Attribute[]): Promise<SearchResult<T>> {
   if (!total || total.length === 0) {
     total = 'total';
   }
@@ -45,9 +45,9 @@ export function queryAndCount<T>(query: (sql: string, args?: any[], m?: StringMa
     if (!list || list.length === 0) {
       return {list: [], total: 0};
     }
-    const t = list[0][total] as number;
+    const t = (list[0] as any)[total] as number;
     for (const obj of list) {
-      delete obj[total];
+      delete (obj as any)[total];
     }
     return {list, total: t};
   });
@@ -57,7 +57,7 @@ const s = 'select';
 const S = 'SELECT';
 const d = ' distinct ';
 const D = ' DISTINCT ';
-export function buildPagingQuery(sql: string, limit: number, offset: number, provider?: string): string {
+export function buildPagingQuery(sql: string, limit: number, offset?: number, provider?: string): string {
   if (limit === undefined || limit == null) {
     limit = 0;
   }
@@ -70,10 +70,13 @@ export function buildPagingQuery(sql: string, limit: number, offset: number, pro
     return buildPagingQueryForOracle(sql, limit, offset);
   }
 }
-export function buildPagingQueryForOracle(sql: string, limit: number, offset: number, total?: string) {
+export function buildPagingQueryForOracle(sql: string, limit: number, offset?: number, total?: string) {
   if (!total || total.length === 0) {
     total = 'total';
   }
+  if (!offset) {
+    offset = 0;
+  }
   let l = d.length;
   let i = sql.indexOf(d);
   if (i < 0) {

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;
@@ -19,6 +19,7 @@ export class SqlLoader<T, ID> {
     protected 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 {
     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 {
@@ -56,10 +63,13 @@ 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 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,
@@ -77,7 +87,7 @@ export class SqlSearchLoader<T, ID, S extends SearchModel> extends SqlLoader<T,
 export interface Manager {
   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[]>;
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
 }
 export function createSqlWriter<T, ID>(table: string,
     manager: Manager,
@@ -151,7 +161,7 @@ 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>>,
       table: string,
@@ -169,7 +179,7 @@ export class SqlSearchWriter<T, ID, S extends SearchModel> extends SqlWriter<T,
     return this.find(s, limit, offset, fields);
   }
 }
-export function createSqlSearchWriter<T, ID, S extends SearchModel>(
+export function createSqlSearchWriter<T, ID, S extends Filter>(
   find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
   table: string,
   manager: Manager,

package/tsconfig.json

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