query-core 0.1.11 → 0.1.15

package/lib/health.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+    function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+    function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+  var _ = { label: 0, sent: function () { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0: case 1: t = op; break;
+        case 4: _.label++; return { value: op[1], done: false };
+        case 5: _.label++; y = op[1]; op = [0]; continue;
+        case 7: op = _.ops.pop(); _.trys.pop(); continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+          if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+          if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+          if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+          if (t[2]) _.ops.pop();
+          _.trys.pop(); continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Checker = (function () {
+  function Checker(select, query, service, timeout) {
+    this.select = select;
+    this.query = query;
+    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);
+  }
+  Checker.prototype.check = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var obj, promise;
+      return __generator(this, function (_a) {
+        obj = {};
+        promise = this.select(this.query).then(function (r) { return obj; });
+        if (this.timeout > 0) {
+          return [2, promiseTimeOut(this.timeout, promise)];
+        }
+        else {
+          return [2, promise];
+        }
+        return [2];
+      });
+    });
+  };
+  Checker.prototype.name = function () {
+    return this.service;
+  };
+  Checker.prototype.build = function (data, err) {
+    if (err) {
+      if (!data) {
+        data = {};
+      }
+      data['error'] = err;
+    }
+    return data;
+  };
+  return Checker;
+}());
+exports.Checker = Checker;
+function promiseTimeOut(timeoutInMilliseconds, promise) {
+  return Promise.race([
+    promise,
+    new Promise(function (resolve, reject) {
+      setTimeout(function () {
+        reject("Timed out in: " + timeoutInMilliseconds + " milliseconds!");
+      }, timeoutInMilliseconds);
+    })
+  ]);
+}
+exports.driverMap = {
+  'oracle': 'SELECT SYSDATE FROM DUAL',
+  'postgres': 'select now()',
+  'mssql': 'select getdate()',
+  'mysql': 'select current_time',
+  'sqlite': 'select date()'
+};
+function createChecker(query, sql, service, timeout) {
+  if (typeof query === 'function') {
+    if (!sql) {
+      sql = 'select getdate()';
+    }
+    return new Checker(query, sql, service, timeout);
+  }
+  else {
+    var db = query;
+    var s = exports.driverMap[db.driver];
+    if (!s) {
+      s = 'select getdate()';
+    }
+    if (!service) {
+      service = db.driver;
+    }
+    return new Checker(db.query, s, service, timeout);
+  }
+}
+exports.createChecker = createChecker;

package/lib/index.js

@@ -3,13 +3,9 @@ function __export(m) {
   for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
+var health_1 = require("./health");
+exports.SqlChecker = health_1.Checker;
 var services_1 = require("./services");
-exports.createGenericSearchRepository = services_1.createSqlSearchWriter;
-exports.createGenericSearchService = services_1.createSqlSearchWriter;
-exports.createRepository = services_1.createSqlSearchWriter;
-exports.createService = services_1.createSqlSearchWriter;
-exports.createGenericRepository = services_1.createSqlWriter;
-exports.createGenericService = services_1.createSqlWriter;
 exports.SqlLoadRepository = services_1.SqlLoader;
 exports.SqlViewRepository = services_1.SqlLoader;
 exports.SqlLoadService = services_1.SqlLoader;
@@ -26,10 +22,11 @@ exports.GenericSearchRepository = services_1.SqlSearchWriter;
 exports.GenericSearchService = services_1.SqlSearchWriter;
 exports.SqlRepository = services_1.SqlSearchWriter;
 exports.SqlService = services_1.SqlSearchWriter;
-exports.Repository = services_1.SqlSearchWriter;
 exports.Service = services_1.SqlSearchWriter;
 exports.SqlGenericRepository = services_1.SqlWriter;
+exports.Repository = services_1.SqlWriter;
 exports.SqlGenericService = services_1.SqlWriter;
+__export(require("./health"));
 __export(require("./build"));
 __export(require("./services"));
 __export(require("./batch"));

package/lib/services.js

@@ -91,18 +91,14 @@ var SqlSearchLoader = (function (_super) {
   return SqlSearchLoader;
 }(SqlLoader));
 exports.SqlSearchLoader = SqlSearchLoader;
-function createSqlWriter(table, manager, attrs, buildParam, toDB, fromDB) {
-  var writer = new SqlWriter(table, manager.query, manager.exec, attrs, buildParam, toDB, fromDB);
-  return writer;
-}
-exports.createSqlWriter = createSqlWriter;
 var SqlWriter = (function (_super) {
   __extends(SqlWriter, _super);
-  function SqlWriter(table, query, exec, attrs, buildParam, toDB, fromDB) {
-    var _this = _super.call(this, table, query, attrs, buildParam, fromDB) || this;
-    _this.exec = exec;
+  function SqlWriter(manager, table, attrs, toDB, fromDB) {
+    var _this = _super.call(this, table, manager.query, attrs, manager.param, fromDB) || this;
     _this.toDB = toDB;
     var x = build_1.version(attrs);
+    _this.exec = manager.exec;
+    _this.execBatch = manager.execBatch;
     if (x) {
       _this.version = x.name;
     }
@@ -162,8 +158,8 @@ var SqlWriter = (function (_super) {
 exports.SqlWriter = SqlWriter;
 var SqlSearchWriter = (function (_super) {
   __extends(SqlSearchWriter, _super);
-  function SqlSearchWriter(find, table, query, exec, attrs, buildParam, toDB, fromDB) {
-    var _this = _super.call(this, table, query, exec, attrs, buildParam, toDB, fromDB) || this;
+  function SqlSearchWriter(find, manager, table, attrs, toDB, fromDB) {
+    var _this = _super.call(this, manager, table, attrs, toDB, fromDB) || this;
     _this.find = find;
     _this.search = _this.search.bind(_this);
     return _this;
@@ -174,8 +170,3 @@ var SqlSearchWriter = (function (_super) {
   return SqlSearchWriter;
 }(SqlWriter));
 exports.SqlSearchWriter = SqlSearchWriter;
-function createSqlSearchWriter(find, table, manager, attrs, buildParam, toDB, fromDB) {
-  var writer = new SqlSearchWriter(find, table, manager.query, manager.exec, attrs, buildParam, toDB, fromDB);
-  return writer;
-}
-exports.createSqlSearchWriter = createSqlSearchWriter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "query-core",
-  "version": "0.1.11",
+  "version": "0.1.15",
   "description": "query",
   "main": "./lib/index.js",
   "types": "./src/index.ts",
@@ -21,6 +21,7 @@
   },
   "keywords": [
     "query",
+    "query-core",
     "sql"
   ]
 }

package/src/health.ts

@@ -0,0 +1,78 @@
+import {StringMap} from './metadata';
+
+export interface SimpleDB {
+  driver: string;
+  query<T>(sql: string): Promise<T[]>;
+}
+export interface AnyMap {
+  [key: string]: any;
+}
+export class Checker {
+  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);
+  }
+  async check(): Promise<AnyMap> {
+    const obj = {} as AnyMap;
+    const promise = this.select(this.query).then(r => obj);
+    if (this.timeout > 0) {
+      return promiseTimeOut(this.timeout, promise);
+    } else {
+      return promise;
+    }
+  }
+  name(): string {
+    return this.service;
+  }
+  build(data: AnyMap, err: any): AnyMap {
+    if (err) {
+      if (!data) {
+        data = {} as AnyMap;
+      }
+      data['error'] = err;
+    }
+    return data;
+  }
+}
+
+function promiseTimeOut(timeoutInMilliseconds: number, promise: Promise<any>): Promise<any> {
+  return Promise.race([
+    promise,
+    new Promise((resolve, reject) => {
+      setTimeout(() => {
+        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') {
+    if (!sql) {
+      sql = 'select getdate()';
+    }
+    return new Checker(query, sql, service, timeout);
+  } else {
+    const db = query as SimpleDB;
+    let s = driverMap[db.driver];
+    if (!s) {
+      s = 'select getdate()';
+    }
+    if (!service) {
+      service = db.driver;
+    }
+    return new Checker(db.query, s, service, timeout);
+  }
+}

package/src/index.ts

@@ -1,8 +1,12 @@
+import {Checker} from './health';
+export {Checker as SqlChecker};
+
 import {Attribute, StringMap} from './metadata';
-import {createSqlSearchWriter, createSqlWriter, SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter} from './services';
+import {SqlLoader, SqlSearchLoader, SqlSearchWriter, SqlWriter} from './services';
 export {SqlLoader as SqlLoadRepository};
 export {SqlLoader as SqlViewRepository};
 export {SqlWriter as SqlGenericRepository};
+export {SqlWriter as Repository};
 
 export {SqlLoader as SqlLoadService};
 export {SqlLoader as SqlViewService};
@@ -21,16 +25,10 @@ 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 './health';
 export * from './build';
 export * from './services';
 export * from './batch';

package/src/services.ts

@@ -15,8 +15,8 @@ export class SqlLoader<T, ID> {
   constructor(public table: string,
     public query: (sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any) => Promise<T[]>,
     attrs: Attributes|string[],
-    protected param: (i: number) => string,
-    protected fromDB?: (v: T) => T) {
+    public param: (i: number) => string,
+    public fromDB?: (v: T) => T) {
     if (Array.isArray(attrs)) {
       this.primaryKeys = attributes(attrs);
       this.attributes = {} as any;
@@ -85,31 +85,31 @@ export class SqlSearchLoader<T, ID, S extends Filter> extends SqlLoader<T, ID> {
   }
 }
 export interface Manager {
+  driver: string;
+  param(i: number): string;
   exec(sql: string, args?: any[], ctx?: any): Promise<number>;
   execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
 }
-export function createSqlWriter<T, ID>(table: string,
-    manager: Manager,
-    attrs: Attributes,
-    buildParam: (i: number) => string,
-    toDB?: (v: T) => T,
-    fromDB?: (v: T) => T) {
-  const writer = new SqlWriter<T, ID>(table, manager.query, manager.exec, attrs, buildParam, toDB, fromDB);
-  return writer;
+export interface DB {
+  driver: string;
+  param(i: number): string;
+  exec(sql: string, args?: any[], ctx?: any): Promise<number>;
+  execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>;
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>;
 }
-
 export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
   version?: string;
-  constructor(table: string,
-    query: (sql: string, args?: any[], m?: StringMap, ctx?: any) => Promise<T[]>,
-    public exec: (sql: string, args?: any[], ctx?: any) => Promise<number>,
+  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,
-    buildParam: (i: number) => string,
-    protected toDB?: (v: T) => T,
+    public toDB?: (v: T) => T,
     fromDB?: (v: T) => T) {
-    super(table, query, attrs, buildParam, fromDB);
+    super(table, manager.query, attrs, manager.param, fromDB);
     const x = version(attrs);
+    this.exec = manager.exec;
+    this.execBatch = manager.execBatch;
     if (x) {
       this.version = x.name;
     }
@@ -163,28 +163,15 @@ export class SqlWriter<T, ID> extends SqlLoader<T, ID> {
 export class SqlSearchWriter<T, ID, S extends Filter> extends SqlWriter<T, ID> {
   constructor(
       protected find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
+      manager: Manager,
       table: string,
-      query: (sql: string, args?: any[], m?: StringMap, ctx?: any) => Promise<T[]>,
-      exec: (sql: string, args?: any[], ctx?: any) => Promise<number>,
       attrs: Attributes,
-      buildParam: (i: number) => string,
       toDB?: (v: T) => T,
       fromDB?: (v: T) => T) {
-    super(table, query, exec, attrs, buildParam, toDB, fromDB);
+    super(manager, table, attrs, toDB, fromDB);
     this.search = this.search.bind(this);
   }
   search(s: S, limit?: number, offset?: number|string, fields?: string[]): Promise<SearchResult<T>> {
     return this.find(s, limit, offset, fields);
   }
 }
-export function createSqlSearchWriter<T, ID, S extends Filter>(
-  find: (s: S, limit?: number, offset?: number|string, fields?: string[]) => Promise<SearchResult<T>>,
-  table: string,
-  manager: Manager,
-  attrs: Attributes,
-  buildParam: (i: number) => string,
-  toDB?: (v: T) => T,
-  fromDB?: (v: T) => T) {
-const writer = new SqlSearchWriter<T, ID, S>(find, table, manager.query, manager.exec, attrs, buildParam, toDB, fromDB);
-return writer;
-}