query-core 0.1.17 → 0.1.20

package/lib/SearchBuilder.js

@@ -54,7 +54,7 @@ var SearchBuilder = (function () {
     var sn = s[st];
     delete s[st];
     var x = (this.provider === exports.postgres ? 'ilike' : this.buildParam);
-    var q2 = this.buildQuery(s, x, this.table, this.attributes, sn, fields, this.q, this.excluding, this.buildSort);
+    var q2 = this.buildQuery(s, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding);
     if (!q2) {
       throw new Error('Cannot build query');
     }

package/lib/query.js

@@ -56,7 +56,7 @@ function buildDollarParam(i) {
   return '$' + i;
 }
 exports.buildDollarParam = buildDollarParam;
-function buildQuery(filter, bparam, table, attrs, sort, fields, sq, strExcluding, buildSort3) {
+function buildQuery(filter, bparam, sort, buildSort3, attrs, table, fields, sq, strExcluding) {
   if (!table || !attrs) {
     return undefined;
   }

package/lib/services.js

@@ -14,6 +14,12 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 var build_1 = require("./build");
+function useGet(table, q, attrs, param, fromDB) {
+  var l = new SqlLoader(table, q, attrs, param, fromDB);
+  return l.load;
+}
+exports.useGet = useGet;
+exports.useLoad = useGet;
 var SqlLoader = (function () {
   function SqlLoader(table, query, attrs, param, fromDB) {
     this.table = table;
@@ -91,6 +97,252 @@ var SqlSearchLoader = (function (_super) {
   return SqlSearchLoader;
 }(SqlLoader));
 exports.SqlSearchLoader = SqlSearchLoader;
+function log(db, isLog, logger, q, result, r, duration) {
+  if (!isLog) {
+    return db;
+  }
+  if (q !== undefined && q != null && q.length > 0) {
+    if (!logger.isDebugEnabled()) {
+      return db;
+    }
+    return new LogManager(db, logger.error, logger.debug, q, result, r, duration);
+  }
+  if (!logger.isInfoEnabled()) {
+    return db;
+  }
+  return new LogManager(db, logger.error, logger.info, q, result, r, duration);
+}
+exports.log = log;
+function useLog(db, isLog, err, lg, q, result, r, duration) {
+  if (!isLog) {
+    return db;
+  }
+  if (err) {
+    return new LogManager(db, err, lg, q, result, r, duration);
+  }
+  return db;
+}
+exports.useLog = useLog;
+var LogManager = (function () {
+  function LogManager(db, err, lg, q, result, r, duration) {
+    this.db = db;
+    this.driver = db.driver;
+    this.duration = (duration && duration.length > 0 ? duration : 'duration');
+    this.sql = (q === undefined ? '' : q);
+    this.return = (r !== undefined && r != null ? r : 'count');
+    this.result = (result !== undefined && result != null ? result : '');
+    this.log = lg;
+    this.error = err;
+    this.param = this.param.bind(this);
+    this.exec = this.exec.bind(this);
+    this.execBatch = this.execBatch.bind(this);
+    this.query = this.query.bind(this);
+    this.queryOne = this.queryOne.bind(this);
+    this.execScalar = this.execScalar.bind(this);
+    this.count = this.count.bind(this);
+  }
+  LogManager.prototype.param = function (i) {
+    return this.db.param(i);
+  };
+  LogManager.prototype.exec = function (sql, args, ctx) {
+    var t1 = new Date();
+    return this.db.exec(sql, args, ctx);
+  };
+  LogManager.prototype.execBatch = function (statements, firstSuccess, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.execBatch(statements, firstSuccess, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = JSON.stringify(statements);
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v;
+          }
+          obj[_this.duration] = d;
+          _this.log('exec batch', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = JSON.stringify(statements);
+        }
+        obj[_this.duration] = d;
+        _this.error('error exec batch: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.query = function (sql, args, m, bools, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.query(sql, args, m, bools, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.result.length > 0) {
+            if (v && v.length > 0) {
+              obj[_this.result] = JSON.stringify(v);
+            }
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v ? v.length : 0;
+          }
+          obj[_this.duration] = d;
+          _this.log('query', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error query: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.queryOne = function (sql, args, m, bools, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.queryOne(sql, args, m, bools, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.result.length > 0) {
+            obj[_this.result] = v ? JSON.stringify(v) : 'null';
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v ? 1 : 0;
+          }
+          obj[_this.duration] = d;
+          _this.log('query one', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error query one: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.execScalar = function (sql, args, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.execScalar(sql, args, ctx).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.result.length > 0) {
+            obj[_this.result] = v ? buildString(v) : 'null';
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v ? 1 : 0;
+          }
+          obj[_this.duration] = d;
+          _this.log('exec scalar', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error exec scalar: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  LogManager.prototype.count = function (sql, args, ctx) {
+    var _this = this;
+    var t1 = new Date();
+    return this.db.count(sql, args).then(function (v) {
+      setTimeout(function () {
+        if (_this.log) {
+          var d = diff(t1);
+          var obj = {};
+          if (_this.sql.length > 0) {
+            obj[_this.sql] = getString(sql, args);
+          }
+          if (_this.return.length > 0) {
+            obj[_this.return] = v;
+          }
+          obj[_this.duration] = d;
+          _this.log('count', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(function (er) {
+      setTimeout(function () {
+        var d = diff(t1);
+        var obj = {};
+        if (_this.sql.length > 0) {
+          obj[_this.sql] = getString(sql, args);
+        }
+        obj[_this.duration] = d;
+        _this.error('error count: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  };
+  return LogManager;
+}());
+exports.LogManager = LogManager;
+function buildString(v) {
+  if (typeof v === 'string') {
+    return v;
+  }
+  else {
+    return JSON.stringify(v);
+  }
+}
+function getString(sql, args) {
+  if (args && args.length > 0) {
+    return sql + ' ' + JSON.stringify(args);
+  }
+  else {
+    return sql;
+  }
+}
+function diff(d1) {
+  var d2 = new Date();
+  return d2.getTime() - d1.getTime();
+}
+exports.diff = diff;
 var SqlWriter = (function (_super) {
   __extends(SqlWriter, _super);
   function SqlWriter(manager, table, attrs, toDB, fromDB) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "query-core",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "description": "query",
   "main": "./lib/index.js",
   "types": "./src/index.ts",

package/src/SearchBuilder.ts

@@ -10,7 +10,7 @@ export const sqlite = 'sqlite';
 export class SearchBuilder<T, S> {
   map?: StringMap;
   bools?: Attribute[];
-  buildQuery: (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|undefined;
+  buildQuery: (s: S, bparam: LikeType|((i: number ) => string), sort?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string, attrs?: Attributes, table?: string, fields?: string[], sq?: string, strExcluding?: string) => Statement|undefined;
   q?: string;
   excluding?: string;
   buildSort?: (sort?: string, map?: Attributes|StringMap) => string;
@@ -19,7 +19,7 @@ export class SearchBuilder<T, S> {
   constructor(public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, public table: string,
     public attributes?: Attributes,
     public provider?: string,
-    buildQ?: (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|undefined,
+    buildQ?: (s: S, bparam: LikeType|((i: number ) => string), sort?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string, attrs?: Attributes, table?: string, fields?: string[], sq?: string, strExcluding?: string) => Statement|undefined,
     public fromDB?: (v: T) => T,
     public sort?: string,
     q?: string,
@@ -62,7 +62,7 @@ export class SearchBuilder<T, S> {
     const sn = (s as any)[st] as string;
     delete (s as any)[st];
     const x = (this.provider === postgres ? 'ilike' : this.buildParam);
-    const q2 = this.buildQuery(s, x, this.table, this.attributes, sn, fields, this.q, this.excluding, this.buildSort);
+    const q2 = this.buildQuery(s, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding);
     if (!q2) {
       throw new Error('Cannot build query');
     }

package/src/batch.ts

@@ -26,6 +26,7 @@ export class SqlInserter<T> {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 export class SqlUpdater<T> {
   version?: string;
   constructor(public exec: (sql: string, args?: any[]) => Promise<number>, public table: string, public attributes: Attributes, public param: (i: number) => string, public map?: (v: T) => T) {
@@ -51,6 +52,7 @@ export class SqlUpdater<T> {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 export class SqlBatchInserter<T> {
   version?: string;
   constructor(public exec: (sql: string, args?: any[]) => Promise<number>, public table: string, public attributes: Attributes, public param: ((i: number) => string)|boolean, public map?: (v: T) => T) {
@@ -80,6 +82,7 @@ export class SqlBatchInserter<T> {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 export class SqlBatchUpdater<T> {
   version?: string;
   constructor(public execBatch: (statements: Statement[]) => Promise<number>, public table: string, public attributes: Attributes, public param: (i: number) => string, protected notSkipInvalid?: boolean, public map?: (v: T) => T) {

package/src/index.ts

@@ -54,6 +54,7 @@ export interface Config {
 export class resource {
   static string?: boolean;
 }
+// tslint:disable-next-line:max-classes-per-file
 export class Loader<T> {
   map?: StringMap;
   constructor(public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>, public sql: string, m?: StringMap, public bools?: Attribute[]) {

package/src/query.ts

@@ -52,7 +52,7 @@ export function buildOracleParam(i: number): string {
 export function buildDollarParam(i: number): string {
   return '$' + i;
 }
-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 {
+export function buildQuery<S>(filter: S, bparam: LikeType|((i: number ) => string), sort?: string, buildSort3?: (sort?: string, map?: Attributes|StringMap) => string, attrs?: Attributes, table?: string, fields?: string[], sq?: string, strExcluding?: string): Statement|undefined {
   if (!table || !attrs) {
     return undefined;
   }

package/src/services.ts

@@ -7,6 +7,17 @@ export interface Filter {
   sort?: string;
   q?: string;
 }
+export type Load<T, ID> = (id: ID, ctx?: any) => Promise<T|null>;
+export type Get<T, ID> = Load<T, ID>;
+export function useGet<T, ID>(table: string,
+  q: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
+  attrs: Attributes|string[],
+  param: (i: number) => string,
+  fromDB?: (v: T) => T): Load<T, ID> {
+  const l = new SqlLoader<T, ID>(table, q, attrs, param, fromDB);
+  return l.load;
+}
+export const useLoad = useGet;
 export class SqlLoader<T, ID> {
   primaryKeys: Attribute[];
   map?: StringMap;
@@ -69,6 +80,7 @@ export class SqlLoader<T, ID> {
     return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then(res => (!res || res.length === 0) ? false : true);
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 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>>,
@@ -91,13 +103,280 @@ export interface Manager {
   execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
 }
-export interface DB {
+export type DB  = Manager;
+export interface ExtManager {
   driver: string;
   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, bools?: Attribute[], ctx?: any): Promise<T[]>;
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T|null>;
+  execScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T>;
+  count(sql: string, args?: any[], ctx?: any): Promise<number>;
+}
+export interface SimpleMap {
+  [key: string]: string|number|boolean|Date;
+}
+export interface Logger {
+  level: number;
+  debug(msg: string, m?: SimpleMap, ctx?: any): void;
+  info(msg: string, m?: SimpleMap, ctx?: any): void;
+  error(msg: string, m?: SimpleMap, ctx?: any): void;
+  isDebugEnabled(): boolean;
+  isInfoEnabled(): boolean;
+}
+export function log(db: ExtManager, isLog: boolean|undefined|null, logger: Logger, q?: string, result?: string, r?: string, duration?: string): ExtManager {
+  if (!isLog) {
+    return db;
+  }
+  if (q !== undefined && q != null && q.length > 0) {
+    if (!logger.isDebugEnabled()) {
+      return db;
+    }
+    return new LogManager(db, logger.error, logger.debug, q, result, r, duration);
+  }
+  if (!logger.isInfoEnabled()) {
+    return db;
+  }
+  return new LogManager(db, logger.error, logger.info, q, result, r, duration);
+}
+export function useLog(db: ExtManager, isLog: boolean|undefined|null, err: ((msg: string, m?: SimpleMap) => void)|undefined, lg?: (msg: string, m?: SimpleMap) => void, q?: string, result?: string, r?: string, duration?: string): ExtManager {
+  if (!isLog) {
+    return db;
+  }
+  if (err) {
+    return new LogManager(db, err, lg, q, result, r, duration);
+  }
+  return db;
+}
+// tslint:disable-next-line:max-classes-per-file
+export class LogManager implements ExtManager {
+  constructor(public db: ExtManager, err: (msg: string, m?: SimpleMap) => void, lg?: (msg: string, m?: SimpleMap) => void, q?: string, result?: string, r?: string, duration?: string) {
+    this.driver = db.driver;
+    this.duration = (duration && duration.length > 0 ? duration : 'duration');
+    this.sql = (q === undefined ? '' : q);
+    this.return = (r !== undefined && r != null ? r : 'count');
+    this.result = (result !== undefined && result != null ? result : '');
+    // this.err = (er ? er : 'error');
+    this.log = lg;
+    this.error = err;
+    this.param = this.param.bind(this);
+    this.exec = this.exec.bind(this);
+    this.execBatch = this.execBatch.bind(this);
+    this.query = this.query.bind(this);
+    this.queryOne = this.queryOne.bind(this);
+    this.execScalar = this.execScalar.bind(this);
+    this.count = this.count.bind(this);
+  }
+  log?: (msg: string, m?: SimpleMap, ctx?: any) => void;
+  error: (msg: string, m?: SimpleMap, ctx?: any) => void;
+  driver: string;
+  duration: string;
+  sql: string;
+  return: string;
+  result: string;
+  // err: string;
+  param(i: number): string {
+    return this.db.param(i);
+  }
+  exec(sql: string, args?: any[], ctx?: any): Promise<number> {
+    const t1 = new Date();
+    return this.db.exec(sql, args, ctx);
+  }
+  execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
+    const t1 = new Date();
+    return this.db.execBatch(statements, firstSuccess, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = JSON.stringify(statements);
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v;
+          }
+          obj[this.duration] = d;
+          this.log('exec batch', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = JSON.stringify(statements);
+        }
+        obj[this.duration] = d;
+        this.error('error exec batch: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]> {
+    const t1 = new Date();
+    return this.db.query<T>(sql, args, m, bools, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.result.length > 0) {
+            if (v && v.length > 0) {
+              obj[this.result] = JSON.stringify(v);
+            }
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v ? v.length : 0;
+          }
+          obj[this.duration] = d;
+          this.log('query', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error query: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T|null> {
+    const t1 = new Date();
+    return this.db.queryOne<T>(sql, args, m, bools, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.result.length > 0) {
+            obj[this.result] = v ? JSON.stringify(v) : 'null';
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v ? 1 : 0;
+          }
+          obj[this.duration] = d;
+          this.log('query one', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error query one: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  execScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T> {
+    const t1 = new Date();
+    return this.db.execScalar<T>(sql, args, ctx).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.result.length > 0) {
+            obj[this.result] = v ? buildString(v) : 'null';
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v ? 1 : 0;
+          }
+          obj[this.duration] = d;
+          this.log('exec scalar', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error exec scalar: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+  count(sql: string, args?: any[], ctx?: any): Promise<number> {
+    const t1 = new Date();
+    return this.db.count(sql, args).then(v => {
+      setTimeout(() => {
+        if (this.log) {
+          const d = diff(t1);
+          const obj: SimpleMap = {} ;
+          if (this.sql.length > 0) {
+            obj[this.sql] = getString(sql, args);
+          }
+          if (this.return.length > 0) {
+            obj[this.return] = v;
+          }
+          obj[this.duration] = d;
+          this.log('count', obj);
+        }
+      }, 0);
+      return v;
+    }).catch(er => {
+      setTimeout(() => {
+        const d = diff(t1);
+        const obj: SimpleMap = {};
+        if (this.sql.length > 0) {
+          obj[this.sql] = getString(sql, args);
+        }
+        obj[this.duration] = d;
+        this.error('error count: ' + buildString(er));
+      }, 0);
+      throw er;
+    });
+  }
+}
+function buildString(v: any): string {
+  if (typeof v === 'string') {
+    return v;
+  } else {
+    return JSON.stringify(v);
+  }
+}
+function getString(sql: string, args?: any[]): string {
+  if (args && args.length > 0) {
+    return sql + ' ' + JSON.stringify(args);
+  } else {
+    return sql;
+  }
+}
+export function diff(d1: Date): number {
+  const d2 = new Date();
+  return d2.getTime() - d1.getTime();
 }
+/*
+const NS_PER_SEC = 1e9;
+const NS_TO_MS = 1e6;
+const getDurationInMilliseconds = (start: [number, number] | undefined) => {
+  const diff = process.hrtime(start);
+  return (diff[0] * NS_PER_SEC + diff[1]) / NS_TO_MS;
+};
+*/
+// tslint:disable-next-line:max-classes-per-file
 export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
   version?: string;
   exec: (sql: string, args?: any[], ctx?: any) => Promise<number>;
@@ -148,8 +427,8 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
       return Promise.resolve(0);
     }
   }
-  patch(obj: T, ctx?: any): Promise<number> {
-    return this.update(obj, ctx);
+  patch(obj: Partial<T>, ctx?: any): Promise<number> {
+    return this.update(obj as any, ctx);
   }
   delete(id: ID, ctx?: any): Promise<number> {
     const stmt = buildToDelete<ID>(id, this.table, this.primaryKeys, this.param);
@@ -160,6 +439,7 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 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>>,

package/tsconfig.json

@@ -13,6 +13,7 @@
     "experimentalDecorators": false,
     "removeComments": true,
     "lib": [
+      "DOM",
       "es7"
     ]
   },