query-core 0.2.7 → 0.2.8

package/lib/SearchBuilder.js

@@ -21,18 +21,22 @@ exports.mssql = "mssql";
 exports.mysql = "mysql";
 exports.sqlite = "sqlite";
 var SearchBuilder = (function () {
-  function SearchBuilder(query, table, attributes, provider, buildQ, fromDB, sort, q, excluding, buildSort, buildParam, total) {
+  function SearchBuilder(query, table, attrs, buildQ, provider, fromDB, sort, q, excluding, buildSort, buildParam, total) {
     this.query = query;
     this.table = table;
-    this.attributes = attributes;
+    this.attrs = attrs;
     this.provider = provider;
     this.fromDB = fromDB;
     this.sort = sort;
-    if (attributes) {
-      this.attributes = attributes;
-      var meta = build_1.metadata(attributes);
+    if (attrs) {
+      this.attrs = attrs;
+      var meta = build_1.metadata(attrs);
       this.map = meta.map;
       this.bools = meta.bools;
+      this.primaryKeys = meta.keys;
+    }
+    else {
+      this.primaryKeys = [];
     }
     this.deleteSort = buildQ ? undefined : true;
     this.buildQuery = buildQ ? buildQ : query_1.buildQuery;
@@ -69,8 +73,8 @@ var SearchBuilder = (function () {
     if (this.deleteSort) {
       delete filter[st];
     }
-    var x = this.provider === exports.postgres ? "ilike" : this.param;
-    var q2 = this.buildQuery(filter, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding);
+    var likeType = this.provider === exports.postgres ? "ilike" : "like";
+    var q2 = this.buildQuery(filter, this.param, sn, this.buildSort, this.attrs, this.table, fields, this.q, this.excluding, likeType);
     if (!q2) {
       throw new Error("Cannot build query");
     }
@@ -93,10 +97,126 @@ var SearchBuilder = (function () {
   return SearchBuilder;
 }());
 exports.SearchBuilder = SearchBuilder;
+var SqlSearchWriter = (function (_super) {
+  __extends(SqlSearchWriter, _super);
+  function SqlSearchWriter(manager, table, attributes, buildQ, provider, toDB, fromDB, sort, q, excluding, buildSort, buildParam, total) {
+    var _this = _super.call(this, manager.query, table, attributes, buildQ, provider, fromDB, sort, q, excluding, buildSort, buildParam, total) || this;
+    _this.attributes = attributes;
+    _this.toDB = toDB;
+    _this.exec = manager.exec;
+    var x = build_1.version(attributes);
+    if (x) {
+      _this.version = x.name;
+    }
+    _this.create = _this.create.bind(_this);
+    _this.update = _this.update.bind(_this);
+    _this.patch = _this.patch.bind(_this);
+    return _this;
+  }
+  SqlSearchWriter.prototype.create = function (obj, ctx) {
+    var obj2 = obj;
+    if (this.toDB) {
+      obj2 = this.toDB(obj);
+    }
+    var stmt = build_1.buildToInsert(obj2, this.table, this.attributes, this.param, this.version);
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx).catch(function (err) {
+        if (err && err.error === "duplicate") {
+          return 0;
+        }
+        else {
+          throw err;
+        }
+      });
+    }
+    else {
+      return Promise.resolve(0);
+    }
+  };
+  SqlSearchWriter.prototype.update = function (obj, ctx) {
+    var obj2 = obj;
+    if (this.toDB) {
+      obj2 = this.toDB(obj);
+    }
+    var stmt = build_1.buildToUpdate(obj2, this.table, this.attributes, this.param, this.version);
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx);
+    }
+    else {
+      return Promise.resolve(0);
+    }
+  };
+  SqlSearchWriter.prototype.patch = function (obj, ctx) {
+    return this.update(obj, ctx);
+  };
+  return SqlSearchWriter;
+}(SearchBuilder));
+exports.SqlSearchWriter = SqlSearchWriter;
+var SqlRepository = (function (_super) {
+  __extends(SqlRepository, _super);
+  function SqlRepository(manager, table, attributes, buildQ, provider, toDB, fromDB, sort, q, excluding, buildSort, buildParam, total) {
+    var _this = _super.call(this, manager, table, attributes, buildQ, provider, toDB, fromDB, sort, q, excluding, buildSort, buildParam, total) || this;
+    _this.attributes = attributes;
+    _this.toDB = toDB;
+    _this.metadata = _this.metadata.bind(_this);
+    _this.all = _this.all.bind(_this);
+    _this.load = _this.load.bind(_this);
+    _this.exist = _this.exist.bind(_this);
+    _this.delete = _this.delete.bind(_this);
+    return _this;
+  }
+  SqlRepository.prototype.metadata = function () {
+    return this.attributes;
+  };
+  SqlRepository.prototype.all = function () {
+    var sql = "select * from " + this.table;
+    return this.query(sql, [], this.map);
+  };
+  SqlRepository.prototype.load = function (id, ctx) {
+    var stmt = build_1.select(id, this.table, this.primaryKeys, this.param);
+    if (!stmt) {
+      throw new Error("cannot build query by id");
+    }
+    var fn = this.fromDB;
+    if (fn) {
+      return this.query(stmt.query, stmt.params, this.map, ctx).then(function (res) {
+        if (!res || res.length === 0) {
+          return null;
+        }
+        else {
+          var obj = res[0];
+          return fn(obj);
+        }
+      });
+    }
+    else {
+      return this.query(stmt.query, stmt.params, this.map).then(function (res) { return (!res || res.length === 0 ? null : res[0]); });
+    }
+  };
+  SqlRepository.prototype.exist = function (id, ctx) {
+    var field = this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name;
+    var stmt = build_1.exist(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(function (res) { return (!res || res.length === 0 ? false : true); });
+  };
+  SqlRepository.prototype.delete = function (id, ctx) {
+    var stmt = build_1.buildToDelete(id, this.table, this.primaryKeys, this.param);
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx);
+    }
+    else {
+      return Promise.resolve(0);
+    }
+  };
+  return SqlRepository;
+}(SqlSearchWriter));
+exports.SqlRepository = SqlRepository;
 var Query = (function (_super) {
   __extends(Query, _super);
-  function Query(query, table, attributes, provider, buildQ, fromDB, sort, q, excluding, buildSort, buildParam, total) {
-    var _this = _super.call(this, query, table, attributes, provider, buildQ, fromDB, sort, q, excluding, buildSort, buildParam, total) || this;
+  function Query(query, table, attributes, buildQ, provider, fromDB, sort, q, excluding, buildSort, buildParam, total) {
+    var _this = _super.call(this, query, table, attributes, buildQ, provider, fromDB, sort, q, excluding, buildSort, buildParam, total) || this;
     var m = build_1.metadata(attributes);
     _this.primaryKeys = m.keys;
     _this.map = m.map;
@@ -110,7 +230,7 @@ var Query = (function (_super) {
     return _this;
   }
   Query.prototype.metadata = function () {
-    return this.attributes;
+    return this.attrs;
   };
   Query.prototype.all = function () {
     var sql = "select * from " + this.table;

package/lib/index.js

@@ -10,11 +10,12 @@ var services_1 = require("./services");
 exports.SqlViewRepository = services_1.SqlLoader;
 exports.SqlLoadService = services_1.SqlLoader;
 exports.SqlViewService = services_1.SqlLoader;
-exports.Repository = services_1.SqlWriter;
-exports.SqlGenericRepository = services_1.SqlWriter;
 exports.SqlGenericService = services_1.SqlWriter;
+exports.GenericRepository = services_1.CRUDRepository;
+exports.SqlGenericRepository = services_1.CRUDRepository;
 var SearchBuilder_1 = require("./SearchBuilder");
 exports.SearchRepository = SearchBuilder_1.SearchBuilder;
+exports.Repository = SearchBuilder_1.SqlRepository;
 __export(require("./batch"));
 __export(require("./build"));
 __export(require("./client"));

package/lib/query.js

@@ -56,25 +56,12 @@ function buildDollarParam(i) {
   return "$" + i;
 }
 exports.buildDollarParam = buildDollarParam;
-function buildQuery(filter, bparam, sort, buildSort3, attrs, table, fields, sq, strExcluding) {
+function buildQuery(filter, param, sort, buildSort3, attrs, table, fields, sq, strExcluding, likeType) {
   if (!table || !attrs) {
     return undefined;
   }
   var s = filter;
-  var like = "like";
-  var param;
-  if (typeof bparam === "string") {
-    if (bparam === "ilike") {
-      like = bparam;
-    }
-    param = buildDollarParam;
-  }
-  else {
-    param = bparam;
-  }
-  if (!like) {
-    like = "like";
-  }
+  var like = likeType ? likeType : "like";
   var filters = [];
   var q;
   var excluding;

package/lib/services.js

@@ -113,139 +113,6 @@ var QueryRepository = (function () {
   return QueryRepository;
 }());
 exports.QueryRepository = QueryRepository;
-var SqlLoadRepository = (function () {
-  function SqlLoadRepository(query, table, attrs, param, id1Field, id2Field, fromDB, id1Col, id2Col) {
-    this.query = query;
-    this.table = table;
-    this.param = param;
-    this.id1Field = id1Field;
-    this.id2Field = id2Field;
-    this.fromDB = fromDB;
-    var m = build_1.metadata(attrs);
-    this.attributes = attrs;
-    this.map = m.map;
-    this.bools = m.bools;
-    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);
-    if (id1Col && id1Col.length > 0) {
-      this.id1Col = id1Col;
-    }
-    else {
-      var c = attrs[this.id1Field];
-      if (c) {
-        this.id1Col = c.column && c.column.length > 0 ? c.column : this.id1Field;
-      }
-      else {
-        this.id1Col = this.id1Field;
-      }
-    }
-    if (id2Col && id2Col.length > 0) {
-      this.id2Col = id2Col;
-    }
-    else {
-      var c = attrs[this.id2Field];
-      if (c) {
-        this.id2Col = c.column && c.column.length > 0 ? c.column : this.id2Field;
-      }
-      else {
-        this.id2Col = this.id2Field;
-      }
-    }
-  }
-  SqlLoadRepository.prototype.metadata = function () {
-    return this.attributes;
-  };
-  SqlLoadRepository.prototype.all = function () {
-    var sql = "select * from " + this.table;
-    return this.query(sql, [], this.map);
-  };
-  SqlLoadRepository.prototype.load = function (id1, id2, ctx) {
-    var _this = this;
-    return this.query("select * from " + this.table + " where " + this.id1Col + " = " + this.param(1) + " and " + this.id2Col + " = " + this.param(2), [id1, id2], this.map, undefined, ctx).then(function (objs) {
-      if (!objs || objs.length === 0) {
-        return null;
-      }
-      else {
-        var fn = _this.fromDB;
-        if (fn) {
-          return fn(objs[0]);
-        }
-        else {
-          return objs[0];
-        }
-      }
-    });
-  };
-  SqlLoadRepository.prototype.exist = function (id1, id2, ctx) {
-    return this.query("select " + this.id1Col + " from " + this.table + " where " + this.id1Col + " = " + this.param(1) + " and " + this.id2Col + " = " + this.param(2), [id1, id2], undefined, undefined, ctx).then(function (objs) {
-      return objs && objs.length > 0 ? true : false;
-    });
-  };
-  return SqlLoadRepository;
-}());
-exports.SqlLoadRepository = SqlLoadRepository;
-var GenericRepository = (function (_super) {
-  __extends(GenericRepository, _super);
-  function GenericRepository(manager, table, attrs, id1Field, id2Field, toDB, fromDB, id1Col, id2Col) {
-    var _this = _super.call(this, manager.query, table, attrs, manager.param, id1Field, id2Field, fromDB, id1Col, id2Col) || this;
-    _this.toDB = toDB;
-    var x = build_1.version(attrs);
-    _this.exec = manager.exec;
-    if (x) {
-      _this.version = x.name;
-    }
-    _this.create = _this.create.bind(_this);
-    _this.update = _this.update.bind(_this);
-    _this.patch = _this.patch.bind(_this);
-    _this.delete = _this.delete.bind(_this);
-    return _this;
-  }
-  GenericRepository.prototype.create = function (obj, ctx) {
-    var obj2 = obj;
-    if (this.toDB) {
-      obj2 = this.toDB(obj);
-    }
-    var stmt = build_1.buildToInsert(obj2, this.table, this.attributes, this.param, this.version);
-    if (stmt) {
-      return this.exec(stmt.query, stmt.params, ctx).catch(function (err) {
-        if (err && err.error === "duplicate") {
-          return 0;
-        }
-        else {
-          throw err;
-        }
-      });
-    }
-    else {
-      return Promise.resolve(0);
-    }
-  };
-  GenericRepository.prototype.update = function (obj, ctx) {
-    var obj2 = obj;
-    if (this.toDB) {
-      obj2 = this.toDB(obj);
-    }
-    var stmt = build_1.buildToUpdate(obj2, this.table, this.attributes, this.param, this.version);
-    if (stmt) {
-      return this.exec(stmt.query, stmt.params, ctx);
-    }
-    else {
-      return Promise.resolve(0);
-    }
-  };
-  GenericRepository.prototype.patch = function (obj, ctx) {
-    return this.update(obj, ctx);
-  };
-  GenericRepository.prototype.delete = function (id1, id2, ctx) {
-    return this.exec("delete from " + this.table + " where " + this.id1Col + " = " + this.param(1) + " and " + this.id2Col + " = " + this.param(2), [id1, id2], ctx);
-  };
-  return GenericRepository;
-}(SqlLoadRepository));
-exports.GenericRepository = GenericRepository;
 function log(db, isLog, logger, q, result, r, duration) {
   if (!isLog) {
     return db;
@@ -538,21 +405,20 @@ function diff(d1) {
   return d2.getTime() - d1.getTime();
 }
 exports.diff = diff;
-var SqlWriter = (function (_super) {
-  __extends(SqlWriter, _super);
-  function SqlWriter(manager, table, attrs, toDB, fromDB) {
-    var _this = _super.call(this, manager.query, table, attrs, manager.param, fromDB) || this;
-    _this.toDB = toDB;
-    var x = build_1.version(attrs);
-    _this.exec = manager.exec;
+var SqlWriter = (function () {
+  function SqlWriter(exec, param, table, attributes, toDB) {
+    this.exec = exec;
+    this.param = param;
+    this.table = table;
+    this.attributes = attributes;
+    this.toDB = toDB;
+    var x = build_1.version(attributes);
     if (x) {
-      _this.version = x.name;
+      this.version = x.name;
     }
-    _this.create = _this.create.bind(_this);
-    _this.update = _this.update.bind(_this);
-    _this.patch = _this.patch.bind(_this);
-    _this.delete = _this.delete.bind(_this);
-    return _this;
+    this.create = this.create.bind(this);
+    this.update = this.update.bind(this);
+    this.patch = this.patch.bind(this);
   }
   SqlWriter.prototype.create = function (obj, ctx) {
     var obj2 = obj;
@@ -590,7 +456,63 @@ var SqlWriter = (function (_super) {
   SqlWriter.prototype.patch = function (obj, ctx) {
     return this.update(obj, ctx);
   };
-  SqlWriter.prototype.delete = function (id, ctx) {
+  return SqlWriter;
+}());
+exports.SqlWriter = SqlWriter;
+var CRUDRepository = (function (_super) {
+  __extends(CRUDRepository, _super);
+  function CRUDRepository(manager, table, attributes, toDB, fromDB) {
+    var _this = _super.call(this, manager.exec, manager.param, table, attributes, toDB) || this;
+    _this.fromDB = fromDB;
+    _this.query = manager.query;
+    var m = build_1.metadata(attributes);
+    _this.primaryKeys = m.keys;
+    _this.map = m.map;
+    _this.bools = m.bools;
+    _this.metadata = _this.metadata.bind(_this);
+    _this.all = _this.all.bind(_this);
+    _this.load = _this.load.bind(_this);
+    _this.exist = _this.exist.bind(_this);
+    _this.delete = _this.delete.bind(_this);
+    return _this;
+  }
+  CRUDRepository.prototype.metadata = function () {
+    return this.attributes;
+  };
+  CRUDRepository.prototype.all = function () {
+    var sql = "select * from " + this.table;
+    return this.query(sql, [], this.map);
+  };
+  CRUDRepository.prototype.load = function (id, ctx) {
+    var stmt = build_1.select(id, this.table, this.primaryKeys, this.param);
+    if (!stmt) {
+      throw new Error("cannot build query by id");
+    }
+    var fn = this.fromDB;
+    if (fn) {
+      return this.query(stmt.query, stmt.params, this.map, ctx).then(function (res) {
+        if (!res || res.length === 0) {
+          return null;
+        }
+        else {
+          var obj = res[0];
+          return fn(obj);
+        }
+      });
+    }
+    else {
+      return this.query(stmt.query, stmt.params, this.map).then(function (res) { return (!res || res.length === 0 ? null : res[0]); });
+    }
+  };
+  CRUDRepository.prototype.exist = function (id, ctx) {
+    var field = this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name;
+    var stmt = build_1.exist(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(function (res) { return (!res || res.length === 0 ? false : true); });
+  };
+  CRUDRepository.prototype.delete = function (id, ctx) {
     var stmt = build_1.buildToDelete(id, this.table, this.primaryKeys, this.param);
     if (stmt) {
       return this.exec(stmt.query, stmt.params, ctx);
@@ -599,6 +521,6 @@ var SqlWriter = (function (_super) {
       return Promise.resolve(0);
     }
   };
-  return SqlWriter;
-}(SqlLoader));
-exports.SqlWriter = SqlWriter;
+  return CRUDRepository;
+}(SqlWriter));
+exports.CRUDRepository = CRUDRepository;

package/package.json

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

package/src/SearchBuilder.ts

@@ -1,4 +1,5 @@
-import { exist, metadata, param, select } from "./build"
+import { Manager } from "./services"
+import { buildToDelete, buildToInsert, buildToUpdate, exist, metadata, param, select, version } from "./build"
 import { Attribute, Attributes, Statement, StringMap } from "./metadata"
 import { buildSort as bs, buildDollarParam, buildMsSQLParam, buildOracleParam, buildQuery, LikeType } from "./query"
 import { buildFromQuery, oracle, SearchResult } from "./search"
@@ -10,10 +11,11 @@ export const sqlite = "sqlite"
 export class SearchBuilder<T, S> {
   map?: StringMap
   bools?: Attribute[]
+  primaryKeys: Attribute[]
   protected deleteSort?: boolean
   buildQuery: (
     s: S,
-    bparam: LikeType | ((i: number) => string),
+    param: (i: number) => string,
     sort?: string,
     buildSort3?: (sort?: string, map?: Attributes | StringMap) => string,
     attrs?: Attributes,
@@ -21,6 +23,7 @@ export class SearchBuilder<T, S> {
     fields?: string[],
     sq?: string,
     strExcluding?: string,
+    likeType?: LikeType
   ) => Statement | undefined
   q?: string
   excluding?: string
@@ -28,13 +31,12 @@ export class SearchBuilder<T, S> {
   param: (i: number) => string
   total?: string
   constructor(
-    public query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
-    public table: string,
-    public attributes?: Attributes,
-    public provider?: string,
+    protected query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
+    protected table: string,
+    protected attrs?: Attributes,
     buildQ?: (
       s: S,
-      bparam: LikeType | ((i: number) => string),
+      bparam: (i: number) => string,
       sort?: string,
       buildSort3?: (sort?: string, map?: Attributes | StringMap) => string,
       attrs?: Attributes,
@@ -42,20 +44,25 @@ export class SearchBuilder<T, S> {
       fields?: string[],
       sq?: string,
       strExcluding?: string,
+      likeType?: LikeType
     ) => Statement | undefined,
-    public fromDB?: (v: T) => T,
-    public sort?: string,
+    protected provider?: string,
+    protected fromDB?: (v: T) => T,
+    protected sort?: string,
     q?: string,
     excluding?: string,
     buildSort?: (sort?: string, map?: Attributes | StringMap) => string,
     buildParam?: (i: number) => string,
     total?: string,
   ) {
-    if (attributes) {
-      this.attributes = attributes
-      const meta = metadata(attributes)
+    if (attrs) {
+      this.attrs = attrs
+      const meta = metadata(attrs)
       this.map = meta.map
       this.bools = meta.bools
+      this.primaryKeys = meta.keys
+    } else {
+      this.primaryKeys = []
     }
     this.deleteSort = buildQ ? undefined : true
     this.buildQuery = buildQ ? buildQ : buildQuery
@@ -86,10 +93,10 @@ export class SearchBuilder<T, S> {
     const st = this.sort ? this.sort : "sort"
     const sn = (filter as any)[st] as string
     if (this.deleteSort) {
-      delete (filter as any)[st]  
+      delete (filter as any)[st]
     }
-    const x = this.provider === postgres ? "ilike" : this.param
-    const q2 = this.buildQuery(filter, x, sn, this.buildSort, this.attributes, this.table, fields, this.q, this.excluding)
+    const likeType = this.provider === postgres ? "ilike" : "like"
+    const q2 = this.buildQuery(filter, this.param, sn, this.buildSort, this.attrs, this.table, fields, this.q, this.excluding, likeType)
     if (!q2) {
       throw new Error("Cannot build query")
     }
@@ -108,6 +115,156 @@ export class SearchBuilder<T, S> {
     }
   }
 }
+export class SqlSearchWriter<T, S> extends SearchBuilder<T, S> {
+  protected version?: string
+  protected exec: (sql: string, args?: any[], ctx?: any) => Promise<number>
+  constructor(
+    manager: Manager,
+    table: string,
+    protected attributes: Attributes,
+    buildQ?: (
+      s: S,
+      param: (i: number) => string,
+      sort?: string,
+      buildSort3?: (sort?: string, map?: Attributes | StringMap) => string,
+      attrs?: Attributes,
+      table?: string,
+      fields?: string[],
+      sq?: string,
+      strExcluding?: string,
+      likeType?: LikeType
+    ) => Statement | undefined,
+    provider?: string,
+    protected toDB?: (v: T) => T,
+    fromDB?: (v: T) => T,
+    sort?: string,
+    q?: string,
+    excluding?: string,
+    buildSort?: (sort?: string, map?: Attributes | StringMap) => string,
+    buildParam?: (i: number) => string,
+    total?: string,
+  ) {
+    super(manager.query, table, attributes, buildQ, provider, fromDB, sort, q, excluding, buildSort, buildParam, total)
+    this.exec = manager.exec
+    const x = version(attributes)
+    if (x) {
+      this.version = x.name
+    }
+    this.create = this.create.bind(this)
+    this.update = this.update.bind(this)
+    this.patch = this.patch.bind(this)
+  }
+  create(obj: T, ctx?: any): Promise<number> {
+    let obj2 = obj
+    if (this.toDB) {
+      obj2 = this.toDB(obj)
+    }
+    const stmt = buildToInsert(obj2, this.table, this.attributes, this.param, this.version)
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx).catch((err) => {
+        if (err && err.error === "duplicate") {
+          return 0
+        } else {
+          throw err
+        }
+      })
+    } else {
+      return Promise.resolve(0)
+    }
+  }
+  update(obj: T, ctx?: any): Promise<number> {
+    let obj2 = obj
+    if (this.toDB) {
+      obj2 = this.toDB(obj)
+    }
+    const stmt = buildToUpdate(obj2, this.table, this.attributes, this.param, this.version)
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx)
+    } else {
+      return Promise.resolve(0)
+    }
+  }
+  patch(obj: Partial<T>, ctx?: any): Promise<number> {
+    return this.update(obj as any, ctx)
+  }
+}
+// tslint:disable-next-line:max-classes-per-file
+export class SqlRepository<T, ID, S> extends SqlSearchWriter<T, S> {
+  constructor(
+    manager: Manager,
+    table: string,
+    protected attributes: Attributes,
+    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,
+    provider?: string,
+    protected toDB?: (v: T) => T,
+    fromDB?: (v: T) => T,
+    sort?: string,
+    q?: string,
+    excluding?: string,
+    buildSort?: (sort?: string, map?: Attributes | StringMap) => string,
+    buildParam?: (i: number) => string,
+    total?: string,
+  ) {
+    super(manager, table, attributes, buildQ, provider, toDB, fromDB, sort, q, excluding, buildSort, buildParam, total)
+    this.metadata = this.metadata.bind(this)
+    this.all = this.all.bind(this)
+    this.load = this.load.bind(this)
+    this.exist = this.exist.bind(this)
+    this.delete = this.delete.bind(this)
+  }
+  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 | null> {
+    const stmt = select<ID>(id, this.table, this.primaryKeys, this.param)
+    if (!stmt) {
+      throw new Error("cannot build query by id")
+    }
+    const fn = this.fromDB
+    if (fn) {
+      return this.query<T>(stmt.query, stmt.params, this.map, ctx).then((res) => {
+        if (!res || res.length === 0) {
+          return null
+        } else {
+          const obj = res[0]
+          return fn(obj)
+        }
+      })
+    } else {
+      return this.query<T>(stmt.query, stmt.params, this.map).then((res) => (!res || res.length === 0 ? null : res[0]))
+    }
+  }
+  exist(id: ID, ctx?: any): Promise<boolean> {
+    const field = this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name
+    const stmt = exist<ID>(id, this.table, this.primaryKeys, this.param, field)
+    if (!stmt) {
+      throw new Error("cannot build query by id")
+    }
+    return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then((res) => (!res || res.length === 0 ? false : true))
+  }
+  delete(id: ID, ctx?: any): Promise<number> {
+    const stmt = buildToDelete<ID>(id, this.table, this.primaryKeys, this.param)
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx)
+    } else {
+      return Promise.resolve(0)
+    }
+  }
+}
 // tslint:disable-next-line:max-classes-per-file
 export class Query<T, ID, S> extends SearchBuilder<T, S> {
   primaryKeys: Attribute[]
@@ -118,7 +275,6 @@ export class Query<T, ID, S> extends SearchBuilder<T, S> {
     query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
     table: string,
     attributes: Attributes,
-    provider?: string,
     buildQ?: (
       s: S,
       bparam: LikeType | ((i: number) => string),
@@ -130,6 +286,7 @@ export class Query<T, ID, S> extends SearchBuilder<T, S> {
       sq?: string,
       strExcluding?: string,
     ) => Statement | undefined,
+    provider?: string,
     fromDB?: (v: T) => T,
     sort?: string,
     q?: string,
@@ -138,7 +295,7 @@ export class Query<T, ID, S> extends SearchBuilder<T, S> {
     buildParam?: (i: number) => string,
     total?: string,
   ) {
-    super(query, table, attributes, provider, buildQ, fromDB, sort, q, excluding, buildSort, buildParam, total)
+    super(query, table, attributes, buildQ, provider, fromDB, sort, q, excluding, buildSort, buildParam, total)
     const m = metadata(attributes)
     this.primaryKeys = m.keys
     this.map = m.map
@@ -151,7 +308,7 @@ export class Query<T, ID, S> extends SearchBuilder<T, S> {
     this.exist = this.exist.bind(this)
   }
   metadata?(): Attributes | undefined {
-    return this.attributes
+    return this.attrs
   }
   all(): Promise<T[]> {
     const sql = `select * from ${this.table}`

package/src/index.ts

@@ -3,14 +3,14 @@ export { Checker as SqlChecker }
 
 import { resource } from "./build"
 import { Attribute, StringMap } from "./metadata"
-import { SqlLoader, SqlWriter } from "./services"
+import { SqlLoader, SqlWriter, CRUDRepository } from "./services"
 // export {SqlLoader as SqlLoadRepository};
-export { SqlWriter as Repository, SqlWriter as SqlGenericRepository, SqlLoader as SqlViewRepository }
+export { CRUDRepository as GenericRepository, CRUDRepository as SqlGenericRepository, SqlLoader as SqlViewRepository }
 
 export { SqlWriter as SqlGenericService, SqlLoader as SqlLoadService, SqlLoader as SqlViewService }
 
-import { SearchBuilder } from "./SearchBuilder"
-export { SearchBuilder as SearchRepository}
+import { SearchBuilder, SqlRepository } from "./SearchBuilder"
+export { SearchBuilder as SearchRepository, SqlRepository as Repository }
 
 export * from "./batch"
 export * from "./build"

package/src/query.ts

@@ -54,7 +54,7 @@ export function buildDollarParam(i: number): string {
 }
 export function buildQuery<S>(
   filter: S,
-  bparam: LikeType | ((i: number) => string),
+  param: ((i: number) => string),
   sort?: string,
   buildSort3?: (sort?: string, map?: Attributes | StringMap) => string,
   attrs?: Attributes,
@@ -62,24 +62,14 @@ export function buildQuery<S>(
   fields?: string[],
   sq?: string,
   strExcluding?: string,
+  likeType?: LikeType
 ): Statement | undefined {
   if (!table || !attrs) {
     return undefined
   }
   const s: any = filter
-  let like = "like"
-  let param: (i: number) => string
-  if (typeof bparam === "string") {
-    if (bparam === "ilike") {
-      like = bparam
-    }
-    param = buildDollarParam
-  } else {
-    param = bparam
-  }
-  if (!like) {
-    like = "like"
-  }
+  let like = likeType ? likeType : "like"
+  // let param: (i: number) => string
   const filters: string[] = []
   let q: string | undefined
   let excluding: string[] | number[] | undefined

package/src/services.ts

@@ -26,11 +26,11 @@ export class SqlLoader<T, ID> {
   attributes: Attributes
   bools?: Attribute[]
   constructor(
-    public query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
-    public table: string,
+    protected query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
+    protected table: string,
     attrs: Attributes | string[],
-    public param: (i: number) => string,
-    public fromDB?: (v: T) => T,
+    protected param: (i: number) => string,
+    protected fromDB?: (v: T) => T,
   ) {
     if (Array.isArray(attrs)) {
       this.primaryKeys = attributes(attrs)
@@ -112,6 +112,7 @@ export class QueryRepository<T, ID> {
     return this.db.query<T>(sql, ids, this.map, this.bools)
   }
 }
+/*
 // tslint:disable-next-line:max-classes-per-file
 export class SqlLoadRepository<T, K1, K2> {
   map?: StringMap
@@ -266,6 +267,7 @@ export class GenericRepository<T, K1, K2> extends SqlLoadRepository<T, K1, K2> {
     return this.exec(`delete from ${this.table} where ${this.id1Col} = ${this.param(1)} and ${this.id2Col} = ${this.param(2)}`, [id1, id2], ctx)
   }
 }
+*/
 /*
 // tslint:disable-next-line:max-classes-per-file
 export class SqlSearchLoader<T, ID, S extends Filter> extends SqlLoader<T, ID> {
@@ -628,14 +630,12 @@ const getDurationInMilliseconds = (start: [number, number] | undefined) => {
 };
 */
 // 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>
+export class SqlWriter<T> {
+  protected version?: string
   // execBatch: (statements: Statement[], firstSuccess?: boolean, ctx?: any) => Promise<number>
-  constructor(manager: Manager, table: string, attrs: Attributes, public toDB?: (v: T) => T, fromDB?: (v: T) => T) {
-    super(manager.query, table, attrs, manager.param, fromDB)
-    const x = version(attrs)
-    this.exec = manager.exec
+  constructor(protected exec: (sql: string, args?: any[], ctx?: any) => Promise<number>, protected param: (i: number) => string, protected table: string, protected attributes: Attributes, public toDB?: (v: T) => T) {
+    // super(manager.query, table, attrs, manager.param, fromDB)
+    const x = version(attributes)
     // this.execBatch = manager.execBatch
     if (x) {
       this.version = x.name
@@ -643,7 +643,7 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
     this.create = this.create.bind(this)
     this.update = this.update.bind(this)
     this.patch = this.patch.bind(this)
-    this.delete = this.delete.bind(this)
+    // this.delete = this.delete.bind(this)
   }
   create(obj: T, ctx?: any): Promise<number> {
     let obj2 = obj
@@ -678,6 +678,70 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
   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)
+    if (stmt) {
+      return this.exec(stmt.query, stmt.params, ctx)
+    } else {
+      return Promise.resolve(0)
+    }
+  }
+    */
+}
+export class CRUDRepository<T, ID> extends SqlWriter<T> {
+  protected primaryKeys: Attribute[]
+  protected map?: StringMap
+  // attributes: Attributes;
+  protected bools?: Attribute[]
+  protected query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>
+  constructor(manager: Manager, table: string, attributes: Attributes, toDB?: (v: T) => T, protected fromDB?: (v: T) => T) {
+    super(manager.exec, manager.param, table, attributes, toDB)
+    this.query = manager.query
+    const m = metadata(attributes)
+    this.primaryKeys = m.keys
+    this.map = m.map
+    this.bools = m.bools
+    this.metadata = this.metadata.bind(this)
+    this.all = this.all.bind(this)
+    this.load = this.load.bind(this)
+    this.exist = this.exist.bind(this)
+    this.delete = this.delete.bind(this)
+  }
+  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 | null> {
+    const stmt = select<ID>(id, this.table, this.primaryKeys, this.param)
+    if (!stmt) {
+      throw new Error("cannot build query by id")
+    }
+    const fn = this.fromDB
+    if (fn) {
+      return this.query<T>(stmt.query, stmt.params, this.map, ctx).then((res) => {
+        if (!res || res.length === 0) {
+          return null
+        } else {
+          const obj = res[0]
+          return fn(obj)
+        }
+      })
+    } else {
+      return this.query<T>(stmt.query, stmt.params, this.map).then((res) => (!res || res.length === 0 ? null : res[0]))
+    }
+  }
+  exist(id: ID, ctx?: any): Promise<boolean> {
+    const field = this.primaryKeys[0].column ? this.primaryKeys[0].column : this.primaryKeys[0].name
+    const stmt = exist<ID>(id, this.table, this.primaryKeys, this.param, field)
+    if (!stmt) {
+      throw new Error("cannot build query by id")
+    }
+    return this.query(stmt.query, stmt.params, this.map, undefined, ctx).then((res) => (!res || res.length === 0 ? false : true))
+  }
   delete(id: ID, ctx?: any): Promise<number> {
     const stmt = buildToDelete<ID>(id, this.table, this.primaryKeys, this.param)
     if (stmt) {