query-core 0.1.6 → 0.1.10

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

@@ -1,17 +1,34 @@
 import {Attribute, StringMap} from './metadata';
 import {createSqlSearchWriter, createSqlWriter, SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter} from './services';
 export {SqlLoader as SqlLoadRepository};
+export {SqlLoader as SqlViewRepository};
 export {SqlWriter as SqlGenericRepository};
+
 export {SqlLoader as SqlLoadService};
+export {SqlLoader as SqlViewService};
 export {SqlWriter as SqlGenericService};
+
 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 {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 +37,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 +94,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 +109,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/metadata.ts

@@ -20,7 +20,8 @@ export interface Statement {
 
 export type DataType = 'ObjectId' | 'date' | 'datetime' | 'time'
     | 'boolean' | 'number' | 'integer' | 'string' | 'text'
-    | 'object' | 'array' | 'primitives' | 'binary';
+    | 'object' | 'array' | 'binary'
+    | 'primitives' | 'booleans' | 'numbers' | 'integers' | 'strings' | 'dates' | 'datetimes' | 'times';
 export type FormatType = 'currency' | 'percentage' | 'email' | 'url' | 'phone' | 'fax' | 'ipv4' | 'ipv6';
 export type MatchType = 'equal' | 'prefix' | 'contain' | 'max' | 'min'; // contain: default for string, min: default for Date, number
 

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) {