query-core 0.2.0 → 0.2.1

package/src/client.ts

@@ -1,202 +1,234 @@
-import {buildToInsert, buildToInsertBatch, buildToUpdate, buildToUpdateBatch} from './build';
-import {handleResults} from './map';
-import {Attribute, Attributes, Statement, StringMap} from './metadata';
+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[];
+  query: string
+  params?: any[]
+  dates?: number[]
 }
 export interface Headers {
-  [key: string]: any;
+  [key: string]: any
 }
 export interface HttpOptionsService {
-  getHttpOptions(): { headers?: Headers };
+  getHttpOptions(): { headers?: Headers }
 }
 export interface HttpRequest {
-  post<T>(url: string, obj: any, options?: {headers?: Headers}): Promise<T>;
+  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>;
+  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[] = [];
+  const d: JStatement[] = []
   if (!s || s.length === 0) {
-    return d;
+    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);
+    const dates = toDates(t.params)
+    const j: JStatement = { query: t.query, params: t.params, dates }
+    d.push(j)
   }
-  return d;
+  return d
 }
 export function toDates(args?: any[]): number[] {
-  const d: number[] = [];
+  const d: number[] = []
   if (!args || args.length === 0) {
-    return d;
+    return d
   }
-  const l = args.length;
+  const l = args.length
   for (let i = 0; i < l; i++) {
     if (args[i] && args[i] instanceof Date) {
-      d.push(i);
+      d.push(i)
     }
   }
-  return d;
+  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.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.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);
+    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};
+    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));
+      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);
+      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);
+    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);
+    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, '');
+    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, '');
+    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, '');
+    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' : '');
+    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));
+      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);
+      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);
+    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);
+    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);
+    const s = buildToInsert(obj, table, attrs, buildParam, ver)
     if (s) {
-      return this.exec(s.query, s.params);
+      return this.exec(s.query, s.params)
     } else {
-      return Promise.resolve(-1);
+      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);
+    const s = buildToUpdate(obj, table, attrs, buildParam, ver)
     if (s) {
-      return this.exec(s.query, s.params);
+      return this.exec(s.query, s.params)
     } else {
-      return Promise.resolve(-1);
+      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);
+    const s = buildToInsertBatch(objs, table, attrs, buildParam)
     if (s) {
-      return this.exec(s.query, s.params);
+      return this.exec(s.query, s.params)
     } else {
-      return Promise.resolve(-1);
+      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);
+    const s = buildToUpdateBatch(objs, table, attrs, buildParam, notSkipInvalid)
     if (s && s.length > 0) {
-      return this.execBatch(s);
+      return this.execBatch(s)
     } else {
-      return Promise.resolve(-1);
+      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);
+    const s = buildToInsert(obj, table, attrs, buildParam, ver)
     if (s) {
-      return this.execWithTx(tx, commit, s.query, s.params);
+      return this.execWithTx(tx, commit, s.query, s.params)
     } else {
-      return Promise.resolve(-1);
+      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);
+    const s = buildToUpdate(obj, table, attrs, buildParam, ver)
     if (s) {
-      return this.execWithTx(tx, commit, s.query, s.params);
+      return this.execWithTx(tx, commit, s.query, s.params)
     } else {
-      return Promise.resolve(-1);
+      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);
+  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);
+      return this.execWithTx(tx, commit, s.query, s.params)
     } else {
-      return Promise.resolve(-1);
+      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);
+  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);
+      return this.execBatchWithTx(tx, commit, s)
     } else {
-      return Promise.resolve(-1);
+      return Promise.resolve(-1)
     }
   }
 }

package/src/health.ts

@@ -1,42 +1,42 @@
-import {StringMap} from './metadata';
+import { StringMap } from "./metadata"
 
 export interface SimpleDB {
-  driver: string;
-  query<T>(sql: string): Promise<T[]>;
+  driver: string
+  query<T>(sql: string): Promise<T[]>
 }
 export interface AnyMap {
-  [key: string]: any;
+  [key: string]: any
 }
 export class Checker {
-  timeout: number;
-  service: string;
+  timeout: number
+  service: string
   constructor(public select: (sql: string) => Promise<any[]>, public query: string, service?: string, timeout?: number) {
-    this.timeout = (timeout ? timeout : 4200);
-    this.service = (service ? service : 'sql');
-    this.check = this.check.bind(this);
-    this.name = this.name.bind(this);
-    this.build = this.build.bind(this);
+    this.timeout = timeout ? timeout : 4200
+    this.service = service ? service : "sql"
+    this.check = this.check.bind(this)
+    this.name = this.name.bind(this)
+    this.build = this.build.bind(this)
   }
   async check(): Promise<AnyMap> {
-    const obj = {} as AnyMap;
-    const promise = this.select(this.query).then(r => obj);
+    const obj = {} as AnyMap
+    const promise = this.select(this.query).then((r) => obj)
     if (this.timeout > 0) {
-      return promiseTimeOut(this.timeout, promise);
+      return promiseTimeOut(this.timeout, promise)
     } else {
-      return promise;
+      return promise
     }
   }
   name(): string {
-    return this.service;
+    return this.service
   }
   build(data: AnyMap, err: any): AnyMap {
     if (err) {
       if (!data) {
-        data = {} as AnyMap;
+        data = {} as AnyMap
       }
-      data['error'] = err;
+      data["error"] = err
     }
-    return data;
+    return data
   }
 }
 
@@ -45,34 +45,34 @@ function promiseTimeOut(timeoutInMilliseconds: number, promise: Promise<any>): P
     promise,
     new Promise((resolve, reject) => {
       setTimeout(() => {
-        reject(`Timed out in: ${timeoutInMilliseconds} milliseconds!`);
-      }, timeoutInMilliseconds);
-    })
-  ]);
+        reject(`Timed out in: ${timeoutInMilliseconds} milliseconds!`)
+      }, timeoutInMilliseconds)
+    }),
+  ])
 }
 
 export const driverMap: StringMap = {
-  'oracle': 'SELECT SYSDATE FROM DUAL',
-  'postgres': 'select now()',
-  'mssql': 'select getdate()',
-  'mysql': 'select current_time',
-  'sqlite': 'select date()'
-};
-export function createChecker(query: SimpleDB|((sql: string) => Promise<any[]>), sql?: string, service?: string, timeout?: number): Checker {
-  if (typeof query === 'function') {
+  oracle: "SELECT SYSDATE FROM DUAL",
+  postgres: "select now()",
+  mssql: "select getdate()",
+  mysql: "select current_time",
+  sqlite: "select date()",
+}
+export function createChecker(query: SimpleDB | ((sql: string) => Promise<any[]>), sql?: string, service?: string, timeout?: number): Checker {
+  if (typeof query === "function") {
     if (!sql) {
-      sql = 'select getdate()';
+      sql = "select getdate()"
     }
-    return new Checker(query, sql, service, timeout);
+    return new Checker(query, sql, service, timeout)
   } else {
-    const db = query as SimpleDB;
-    let s = driverMap[db.driver];
+    const db = query as SimpleDB
+    let s = driverMap[db.driver]
     if (!s) {
-      s = 'select getdate()';
+      s = "select getdate()"
     }
     if (!service) {
-      service = db.driver;
+      service = db.driver
     }
-    return new Checker(db.query, s, service, timeout);
+    return new Checker(db.query, s, service, timeout)
   }
 }

package/src/index.ts

@@ -1,112 +1,117 @@
-import {Checker} from './health';
-export {Checker as SqlChecker};
+import { Checker } from "./health"
+export { Checker as SqlChecker }
 
-import {resource} from './build';
-import {Attribute, StringMap} from './metadata';
-import {SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter} from './services';
+import { resource } from "./build"
+import { Attribute, StringMap } from "./metadata"
+import { SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter } from "./services"
 // export {SqlLoader as SqlLoadRepository};
-export {SqlLoader as SqlViewRepository};
-export {SqlWriter as SqlGenericRepository};
-export {SqlWriter as Repository};
+export { SqlWriter as Repository, SqlWriter as SqlGenericRepository, SqlLoader as SqlViewRepository }
 
-export {SqlLoader as SqlLoadService};
-export {SqlLoader as SqlViewService};
-export {SqlWriter as SqlGenericService};
+export { SqlWriter as SqlGenericService, SqlLoader as SqlLoadService, SqlLoader as SqlViewService }
 
-export {SqlSearchLoader as ViewSearchRepository};
-export {SqlSearchLoader as ViewSearchService};
-export {SqlSearchLoader as SqlViewSearchRepository};
-export {SqlSearchLoader as SqlViewSearchService};
-export {SqlSearchLoader as SqlSearchRepository};
-export {SqlSearchLoader as SqlSearchService};
-export {SqlSearchLoader as SearchRepository};
-export {SqlSearchLoader as SearchService};
+export {
+  SqlSearchLoader as SearchRepository,
+  SqlSearchLoader as SearchService,
+  SqlSearchLoader as SqlSearchRepository,
+  SqlSearchLoader as SqlSearchService,
+  SqlSearchLoader as SqlViewSearchRepository,
+  SqlSearchLoader as SqlViewSearchService,
+  SqlSearchLoader as ViewSearchRepository,
+  SqlSearchLoader as ViewSearchService,
+}
 
-export {SqlSearchWriter as GenericSearchRepository};
-export {SqlSearchWriter as GenericSearchService};
-export {SqlSearchWriter as SqlRepository};
-export {SqlSearchWriter as SqlService};
-export {SqlSearchWriter as Service};
+export {
+  SqlSearchWriter as GenericSearchRepository,
+  SqlSearchWriter as GenericSearchService,
+  SqlSearchWriter as Service,
+  SqlSearchWriter as SqlRepository,
+  SqlSearchWriter as SqlService,
+}
 
-export * from './metadata';
-export * from './health';
-export * from './build';
-export * from './services';
-export * from './batch';
-export * from './query';
-export * from './search';
-export * from './SearchBuilder';
-export * from './client';
+export * from "./batch"
+export * from "./build"
+export * from "./client"
+export * from "./health"
+export * from "./metadata"
+export * from "./query"
+export * from "./search"
+export * from "./SearchBuilder"
+export * from "./services"
 
 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;
+  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: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[]) {
-    this.map = m;
-    this.load = this.load.bind(this);
+  map?: StringMap
+  constructor(
+    public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[]) => Promise<T[]>,
+    public sql: string,
+    m?: StringMap,
+    public bools?: Attribute[],
+  ) {
+    this.map = m
+    this.load = this.load.bind(this)
   }
   load(): Promise<T[]> {
-    return this.query(this.sql, [], this.map, this.bools);
+    return this.query(this.sql, [], this.map, this.bools)
   }
 }
 export function toArray(arr: any[]): any[] {
   if (!arr || arr.length === 0) {
-    return [];
+    return []
   }
-  const p: any[] = [];
-  const l = arr.length;
+  const p: any[] = []
+  const l = arr.length
   for (let i = 0; i < l; i++) {
     if (arr[i] === undefined || arr[i] == null) {
-      p.push(null);
+      p.push(null)
     } else {
-      if (typeof arr[i] === 'object') {
+      if (typeof arr[i] === "object") {
         if (arr[i] instanceof Date) {
-          p.push(arr[i]);
+          p.push(arr[i])
         } else {
           if (resource.string) {
-            const s: string = JSON.stringify(arr[i]);
-            p.push(s);
+            const s: string = JSON.stringify(arr[i])
+            p.push(s)
           } else {
-            p.push(arr[i]);
+            p.push(arr[i])
           }
         }
       } else {
-        p.push(arr[i]);
+        p.push(arr[i])
       }
     }
   }
-  return p;
+  return p
 }
 export function map<T>(obj: T, m?: StringMap): any {
   if (!m) {
-    return obj;
+    return obj
   }
-  const mkeys = Object.keys(m);
+  const mkeys = Object.keys(m)
   if (mkeys.length === 0) {
-    return obj;
+    return obj
   }
-  const obj2: any = {};
-  const keys = Object.keys(obj as any);
+  const obj2: any = {}
+  const keys = Object.keys(obj as any)
   for (const key of keys) {
-    let k0 = m[key];
+    let k0 = m[key]
     if (!k0) {
-      k0 = key;
+      k0 = key
     }
-    obj2[k0] = (obj as any)[key];
+    obj2[k0] = (obj as any)[key]
   }
-  return obj2;
+  return obj2
 }