query-core 0.1.22 → 0.1.25

package/lib/index.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var health_1 = require("./health");
 exports.SqlChecker = health_1.Checker;
 var services_1 = require("./services");
-exports.SqlLoadRepository = services_1.SqlLoader;
 exports.SqlViewRepository = services_1.SqlLoader;
 exports.SqlLoadService = services_1.SqlLoader;
 exports.SqlViewService = services_1.SqlLoader;

package/lib/services.js

@@ -83,6 +83,170 @@ var SqlLoader = (function () {
   return SqlLoader;
 }());
 exports.SqlLoader = SqlLoader;
+var QueryRepository = (function () {
+  function QueryRepository(db, table, attrs, sort, id) {
+    this.db = db;
+    this.table = table;
+    this.attrs = attrs;
+    this.sort = sort;
+    this.id = (id && id.length > 0 ? id : 'id');
+    this.query = this.query.bind(this);
+    var m = build_1.metadata(attrs);
+    this.map = m.map;
+    this.bools = m.bools;
+  }
+  QueryRepository.prototype.query = function (ids) {
+    if (!ids || ids.length === 0) {
+      return Promise.resolve([]);
+    }
+    var ps = [];
+    var length = ids.length;
+    for (var i = 1; i <= length; i++) {
+      ps.push(this.db.param(i));
+    }
+    var sql = "select * from " + this.table + " where " + this.id + " in (" + ps.join(',') + ")";
+    if (this.sort && this.sort.length > 0) {
+      sql = sql + ' order by ' + this.sort;
+    }
+    return this.db.query(sql, ids, this.map, this.bools);
+  };
+  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;
+    _this.execBatch = manager.execBatch;
+    if (x) {
+      _this.version = x.name;
+    }
+    _this.insert = _this.insert.bind(_this);
+    _this.update = _this.update.bind(_this);
+    _this.patch = _this.patch.bind(_this);
+    _this.delete = _this.delete.bind(_this);
+    return _this;
+  }
+  GenericRepository.prototype.insert = 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;
 var SqlSearchLoader = (function (_super) {
   __extends(SqlSearchLoader, _super);
   function SqlSearchLoader(find, query, table, attrs, param, fromDB) {

package/package.json

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

package/src/SearchBuilder.ts

@@ -82,6 +82,7 @@ export class SearchBuilder<T, S> {
     }
   }
 }
+// tslint:disable-next-line:max-classes-per-file
 export class Query<T, ID, S> extends SearchBuilder<T, S> {
   primaryKeys: Attribute[];
   map?: StringMap;

package/src/index.ts

@@ -3,7 +3,7 @@ export {Checker as SqlChecker};
 
 import {Attribute, StringMap} from './metadata';
 import {SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter} from './services';
-export {SqlLoader as SqlLoadRepository};
+// export {SqlLoader as SqlLoadRepository};
 export {SqlLoader as SqlViewRepository};
 export {SqlWriter as SqlGenericRepository};
 export {SqlWriter as Repository};

package/src/services.ts

@@ -83,6 +83,173 @@ export class SqlLoader<T, ID> {
   }
 }
 // tslint:disable-next-line:max-classes-per-file
+export class QueryRepository<T, ID> {
+  constructor(public db: DB, public table: string, public attrs: Attributes, public sort?: string, id?: string) {
+    this.id = (id && id.length > 0 ? id : 'id');
+    this.query = this.query.bind(this);
+    const m = metadata(attrs);
+    this.map = m.map;
+    this.bools = m.bools;
+  }
+  id: string;
+  map?: StringMap;
+  bools?: Attribute[];
+  query(ids: ID[]): Promise<T[]> {
+    if (!ids || ids.length === 0) {
+      return Promise.resolve([]);
+    }
+    const ps: string[] = [];
+    const length = ids.length;
+    for (let i = 1; i <= length; i++) {
+      ps.push(this.db.param(i));
+    }
+    let sql = `select * from ${this.table} where ${this.id} in (${ps.join(',')})`;
+    if (this.sort && this.sort.length > 0) {
+      sql = sql + ' order by ' + this.sort;
+    }
+    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;
+  attributes: Attributes;
+  bools?: Attribute[];
+  id1Col: string;
+  id2Col: string;
+  constructor(
+    public query: <K>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<K[]>,
+    public table: string,
+    attrs: Attributes,
+    public param: (i: number) => string,
+    public id1Field: string,
+    public id2Field: string,
+    public fromDB?: (v: T) => T,
+    id1Col?: string,
+    id2Col?: string) {
+
+    const m = 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 {
+      const 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 {
+      const c = attrs[this.id2Field];
+      if (c) {
+        this.id2Col = (c.column && c.column.length > 0 ? c.column : this.id2Field);
+      } else {
+        this.id2Col = this.id2Field;
+      }
+    }
+  }
+  metadata?(): Attributes|undefined {
+    return this.attributes;
+  }
+  all(): Promise<T[]> {
+    const sql = `select * from ${this.table}`;
+    return this.query(sql, [], this.map);
+  }
+  load(id1: K1, id2: K2, ctx?: any): Promise<T|null> {
+    return this.query<T>(`select * from ${this.table} where ${this.id1Col} = ${this.param(1)} and ${this.id2Col} = ${this.param(2)}`, [id1, id2], this.map, undefined, ctx).then(objs => {
+      if (!objs || objs.length === 0) {
+        return null;
+      } else {
+        const fn = this.fromDB;
+        if (fn) {
+          return fn(objs[0]);
+        } else {
+          return objs[0];
+        }
+      }
+    });
+  }
+  exist(id1: K1, id2: K2, ctx?: any): Promise<boolean> {
+    return this.query<T>(`select ${this.id1Col} from ${this.table} where ${this.id1Col} = ${this.param(1)} and ${this.id2Col} = ${this.param(2)}`, [id1, id2], undefined, undefined, ctx).then(objs => {
+      return (objs && objs.length > 0 ? true : false);
+    });
+  }
+}
+// tslint:disable-next-line:max-classes-per-file
+export class GenericRepository<T, K1, K2> extends SqlLoadRepository<T, K1, K2> {
+  version?: string;
+  exec: (sql: string, args?: any[], ctx?: any) => Promise<number>;
+  execBatch: (statements: Statement[], firstSuccess?: boolean, ctx?: any) => Promise<number>;
+  constructor(manager: Manager, table: string,
+    attrs: Attributes,
+    id1Field: string,
+    id2Field: string,
+    public toDB?: (v: T) => T,
+    fromDB?: (v: T) => T,
+    id1Col?: string,
+    id2Col?: string) {
+    super(manager.query, table, attrs, manager.param, id1Field, id2Field, fromDB, id1Col, id2Col);
+    const x = version(attrs);
+    this.exec = manager.exec;
+    this.execBatch = manager.execBatch;
+    if (x) {
+      this.version = x.name;
+    }
+    this.insert = this.insert.bind(this);
+    this.update = this.update.bind(this);
+    this.patch = this.patch.bind(this);
+    this.delete = this.delete.bind(this);
+  }
+  insert(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);
+  }
+  delete(id1: K1, id2: K2, ctx?: any): Promise<number> {
+    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> {
   constructor(
       protected find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,