core-express 0.1.0 → 0.1.1

package/src/LoadController.ts

@@ -1,65 +1,95 @@
-import {Request, Response} from 'express';
-import {Attribute, Attributes, Model} from './metadata';
-import {handleError} from './response';
-import {buildId, buildKeys} from './view';
+import { Request, Response } from "express"
+import { attrs, handleError, minimize, queryNumber, respondModel } from "./http"
+import { Attribute, Attributes } from "./metadata"
+import { buildAndCheckId, buildKeys } from "./view"
 
 export interface ViewService<T, ID> {
-  metadata?(): Model;
-  load(id: ID, ctx?: any): Promise<T>;
+  metadata?(): Attributes | undefined
+  load(id: ID, ctx?: any): Promise<T | null>
 }
-function getViewFunc<T, ID>(viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>)): (id: ID, ctx?: any) => Promise<T> {
-  if (typeof viewService === 'function') {
-    return viewService;
+export type Load<T, ID> = (id: ID, ctx?: any) => Promise<T | null>
+function getViewFunc<T, ID>(viewService: ViewService<T, ID> | Load<T, ID>): (id: ID, ctx?: any) => Promise<T | null> {
+  if (typeof viewService === "function") {
+    return viewService
   }
-  return viewService.load;
+  return viewService.load
 }
-function getKeysFunc<T, ID>(viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>), keys?: Attributes|Attribute[]|string[]): Attribute[] {
+function getKeysFunc<T, ID>(viewService: ViewService<T, ID> | Load<T, ID>, keys?: Attributes | Attribute[] | string[]): Attribute[] | undefined {
   if (keys) {
     if (Array.isArray(keys)) {
       if (keys.length > 0) {
-        if (typeof keys[0] === 'string') {
-          const attrs: Attribute[] = [];
-          for (const str of keys) {
-            const attr: Attribute = {name: str as string, type: 'string'};
-            attrs.push(attr);
-          }
-          return attrs;
+        if (typeof keys[0] === "string") {
+          return attrs(keys as string[])
         } else {
-          return keys as Attribute[];
+          return keys as Attribute[]
         }
       }
-      return undefined;
+      return undefined
     } else {
-      return buildKeys(keys as Attributes);
+      return buildKeys(keys as Attributes)
     }
   }
-  if (typeof viewService !== 'function' && viewService.metadata) {
-    const metadata = viewService.metadata();
+  if (typeof viewService !== "function" && viewService.metadata) {
+    const metadata = viewService.metadata()
     if (metadata) {
-      return buildKeys(metadata.attributes);
+      return buildKeys(metadata)
     }
   }
-  return undefined;
+  return undefined
 }
 export class LoadController<T, ID> {
-  protected keys?: Attribute[];
-  protected view: (id: ID, ctx?: any) => Promise<T>;
-  constructor(protected log: (msg: any, ctx?: any) => void, viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>), keys?: Attributes|Attribute[]|string[]) {
-    this.load = this.load.bind(this);
-    this.view = getViewFunc(viewService);
-    this.keys = getKeysFunc(viewService, keys);
+  protected keys?: Attribute[]
+  protected view: Load<T, ID>
+  constructor(viewService: ViewService<T, ID> | Load<T, ID>, keys?: Attributes | Attribute[] | string[]) {
+    this.load = this.load.bind(this)
+    this.view = getViewFunc(viewService)
+    this.keys = getKeysFunc(viewService, keys)
   }
-  load(req: Request, res: Response) {
-    const id = buildId<ID>(req, this.keys);
-    if (!id) {
-      return res.status(400).end('invalid parameters');
+  load(req: Request, res: Response): void {
+    const id = buildAndCheckId<ID>(req, res, this.keys)
+    if (id) {
+      this.view(id)
+        .then((obj) => respondModel(minimize(obj), res))
+        .catch((err) => handleError(err, res))
     }
-    this.view(id).then(obj => {
-      if (obj) {
-        res.status(200).json(obj);
+  }
+}
+// tslint:disable-next-line:max-classes-per-file
+export class ItemController<T> {
+  constructor(
+    private loadData: (keyword: string, max?: number) => Promise<T>,
+    name?: string,
+    protected param?: boolean,
+    max?: number,
+    maxName?: string,
+  ) {
+    this.name = name && name.length > 0 ? name : "keyword"
+    this.max = max && max > 0 ? max : 20
+    this.maxName = maxName && maxName.length > 0 ? maxName : "max"
+    this.load = this.load.bind(this)
+    this.query = this.query.bind(this)
+  }
+  name: string
+  max: number
+  maxName: string
+  query(req: Request, res: Response) {
+    return this.load(req, res)
+  }
+  load(req: Request, res: Response) {
+    const v = this.param ? req.params[this.name] : req.query[this.name]
+    if (!v) {
+      res.status(400).end(`'${this.name}' cannot be empty`)
+    } else {
+      const s = v.toString()
+      if (s.length === 0) {
+        res.status(400).end(`'${this.name}' cannot be empty`)
       } else {
-        res.status(404).json(null);
+        const max = queryNumber(req, this.maxName, this.max)
+        this.loadData(s, max)
+          .then((result) => respondModel(minimize(result), res))
+          .catch((err) => handleError(err, res))
       }
-    }).catch(err => handleError(err, res, this.log));
+    }
   }
 }
+export { ItemController as ItemHandler }

package/src/LoadSearchController.ts

@@ -1,31 +1,124 @@
-import {Request, Response} from 'express';
-import {LoadController, ViewService} from './LoadController';
-import {Attribute, Attributes} from './metadata';
-import {handleError} from './response';
-import {fromRequest, getLimit, initializeConfig, jsonResult, SearchConfig, SearchModel, SearchResult} from './search';
+import { Request, Response } from "express"
+import { handleError } from "./http"
+import { LoadController, ViewService } from "./LoadController"
+import { Attribute, Attributes } from "./metadata"
+import { resources } from "./resources"
+import { buildArray, Filter, format, fromRequest, getMetadataFunc, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult } from "./search"
 
-export class LoadSearchController<T, ID, S extends SearchModel> extends LoadController<T, ID> {
-  config?: SearchConfig;
-  csv?: boolean;
-  constructor(log: (msg: any, ctx?: any) => void, public find: (s: S, limit?: number, skip?: number, refId?: string) => Promise<SearchResult<T>>, viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>), keys?: Attributes|Attribute[]|string[], config?: SearchConfig|boolean, public format?: (s: S) => S) {
-    super(log, viewService, keys);
-    this.search = this.search.bind(this);
+export interface Search {
+  search(req: Request, res: Response): void
+  load(req: Request, res: Response): void
+}
+export interface Query<T, ID, S> extends ViewService<T, ID> {
+  search: (s: S, limit: number, page?: number | string, fields?: string[]) => Promise<SearchResult<T>>
+  metadata?(): Attributes | undefined
+  load(id: ID, ctx?: any): Promise<T | null>
+}
+export interface SearchManager {
+  search(req: Request, res: Response): void
+  load(req: Request, res: Response): void
+}
+export function useSearchController<T, ID, S extends Filter>(
+  find: (s: S, limit: number, page?: number | string, fields?: string[]) => Promise<SearchResult<T>>,
+  viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>),
+  array?: string[],
+  dates?: string[],
+  numbers?: string[],
+  keys?: Attributes | Attribute[] | string[],
+  config?: SearchConfig | boolean,
+): Search {
+  const c = new LoadSearchController(find, viewService, keys, config, dates, numbers)
+  c.array = array
+  return c
+}
+export const useSearchHandler = useSearchController
+export const createSearchController = useSearchController
+export const createSearchHandler = useSearchController
+export class LoadSearchController<T, ID, S extends Filter> extends LoadController<T, ID> {
+  config?: SearchConfig
+  csv?: boolean
+  dates?: string[]
+  numbers?: string[]
+  excluding?: string
+  array?: string[]
+  constructor(
+    public find: (s: S, limit: number, page?: number | string, fields?: string[]) => Promise<SearchResult<T>>,
+    viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>),
+    keys?: Attributes | Attribute[] | string[],
+    config?: SearchConfig | boolean,
+    dates?: string[],
+    numbers?: string[],
+  ) {
+    super(viewService, keys)
+    this.search = this.search.bind(this)
     if (config) {
-      if (typeof config === 'boolean') {
-        this.csv = config;
+      if (typeof config === "boolean") {
+        this.csv = config
       } else {
-        this.config = initializeConfig(config);
+        this.config = initializeConfig(config)
         if (this.config) {
-          this.csv = this.config.csv;
+          this.csv = this.config.csv
+          this.excluding = this.config.excluding
         }
       }
     }
+    const m = getMetadataFunc(viewService, dates, numbers, keys)
+    if (m) {
+      this.dates = m.dates
+      this.numbers = m.numbers
+    }
+  }
+  search(req: Request, res: Response): void {
+    const s = fromRequest<S>(req, buildArray(this.array, resources.fields, this.excluding))
+    const l = getParameters(s)
+    const s2 = format(s, this.dates, this.numbers)
+    this.find(s2, l.limit, l.pageOrNextPageToken, l.fields)
+      .then((result) => jsonResult(res, result, this.csv, l.fields, this.config))
+      .catch((err) => handleError(err, res))
+  }
+}
+export class QueryController<T, ID, S extends Filter> extends LoadController<T, ID> {
+  config?: SearchConfig
+  csv?: boolean
+  dates?: string[]
+  numbers?: string[]
+  excluding?: string
+  array?: string[]
+  constructor(
+    protected query: Query<T, ID, S>,
+    config?: SearchConfig | boolean,
+    dates?: string[],
+    numbers?: string[],
+    array?: string[],
+  ) {
+    super(query)
+    this.search = this.search.bind(this)
+    this.array = array
+    if (config) {
+      if (typeof config === "boolean") {
+        this.csv = config
+      } else {
+        this.config = initializeConfig(config)
+        if (this.config) {
+          this.csv = this.config.csv
+          this.excluding = this.config.excluding
+        }
+      }
+    }
+    const m = getMetadataFunc(query, dates, numbers)
+    if (m) {
+      this.dates = m.dates
+      this.numbers = m.numbers
+    }
   }
-  search(req: Request, res: Response) {
-    const s = fromRequest<S>(req, this.format);
-    const l = getLimit(s);
-    this.find(s, l.limit, l.skip, l.refId)
-      .then(result => jsonResult(res, result, this.csv, s.fields, this.config))
-      .catch(err => handleError(err, res, this.log));
+  search(req: Request, res: Response): void {
+    const s = fromRequest<S>(req, buildArray(this.array, resources.fields, this.excluding))
+    const l = getParameters(s)
+    const s2 = format(s, this.dates, this.numbers)
+    this.query
+      .search(s2, l.limit, l.pageOrNextPageToken, l.fields)
+      .then((result) => jsonResult(res, result, this.csv, l.fields, this.config))
+      .catch((err) => handleError(err, res))
   }
 }
+export { QueryController as QueryHandler }

package/src/LogController.ts

@@ -0,0 +1,137 @@
+import { Request, Response } from "express"
+import { SimpleMap } from "./log"
+
+export interface NumberMap {
+  [key: string]: number
+}
+export interface LogConfig {
+  level?: string
+  map?: LogMapConfig
+  constants?: SimpleMap
+  name?: Name
+}
+export interface LogMapConfig {
+  time?: string
+  level?: string
+  msg?: string
+}
+export interface LogMap {
+  time: string
+  level: string
+  msg: string
+}
+export interface Name {
+  trace: string
+  debug: string
+  info: string
+  warn: string
+  error: string
+  panic: string
+  fatal: string
+}
+export interface Logger {
+  name: Name
+  level: number
+  map: LogMap
+  constants?: SimpleMap
+  trace(msg: string, m?: SimpleMap, ctx?: any): void
+  debug(msg: string, m?: SimpleMap, ctx?: any): void
+  info(msg: string, m?: SimpleMap, ctx?: any): void
+  warn(msg: string, m?: SimpleMap, ctx?: any): void
+  error(msg: string, m?: SimpleMap, ctx?: any): void
+  panic(msg: string, m?: SimpleMap, ctx?: any): void
+  fatal(msg: string, m?: SimpleMap, ctx?: any): void
+  isLevelEnabled(level: number): boolean
+  isTraceEnabled(): boolean
+  isDebugEnabled(): boolean
+  isInfoEnabled(): boolean
+  isWarnEnabled(): boolean
+  isErrorEnabled(): boolean
+  isPanicEnabled(): boolean
+  isFatalEnabled(): boolean
+}
+export const map: NumberMap = {
+  TRACE: -2,
+  DEBUG: -1,
+  INFO: 0,
+  WARN: 1,
+  ERROR: 2,
+  PANIC: 3,
+  FATAL: 4,
+}
+export class LogController {
+  map: NumberMap
+  update: (logger: Logger, obj: LogConfig, mp: NumberMap) => boolean
+  constructor(public logger: Logger, updateL?: (logger: Logger, obj: LogConfig, mp: NumberMap) => boolean, mp?: NumberMap) {
+    this.map = mp ? mp : map
+    this.update = updateL ? updateL : updateLog
+    this.config = this.config.bind(this)
+  }
+  config(req: Request, res: Response) {
+    const obj: LogConfig = req.body
+    if (!this.logger) {
+      res.status(503).end("Logger is not available")
+      return
+    }
+    if (typeof obj.level === "string" && obj.level.length > 0) {
+      if (!this.map) {
+        res.status(503).end("Map is not available")
+        return
+      }
+    }
+    const changed = this.update(this.logger, obj, this.map)
+    if (changed) {
+      res.status(200).json(true).end()
+    } else {
+      res.status(204).json(false).end()
+    }
+  }
+}
+export function updateLog(logger: Logger, obj: LogConfig, mp: NumberMap): boolean {
+  let changed = false
+  if (typeof obj.level === "string" && obj.level.length > 0) {
+    const lv = mp[obj.level.toUpperCase()]
+    if (lv !== undefined) {
+      logger.level = lv
+      changed = true
+    }
+  }
+  if (obj.map) {
+    if (typeof obj.map.level === "string" && obj.map.level.length > 0) {
+      logger.map.level = obj.map.level
+      changed = true
+    }
+    if (typeof obj.map.time === "string" && obj.map.time.length > 0) {
+      logger.map.time = obj.map.time
+      changed = true
+    }
+    if (typeof obj.map.msg === "string" && obj.map.msg.length > 0) {
+      logger.map.msg = obj.map.msg
+      changed = true
+    }
+  }
+  if (obj.constants !== undefined && typeof obj.constants === "object") {
+    const ks = Object.keys(obj.constants)
+    if (ks.length > 0) {
+      logger.constants = obj.constants
+    } else {
+      logger.constants = undefined
+    }
+    changed = true
+  }
+  if (obj.name) {
+    if (
+      typeof obj.name.trace === "string" &&
+      typeof obj.name.debug === "string" &&
+      typeof obj.name.info === "string" &&
+      typeof obj.name.warn === "string" &&
+      typeof obj.name.error === "string" &&
+      typeof obj.name.panic === "string" &&
+      typeof obj.name.fatal === "string"
+    ) {
+      logger.name = obj.name
+      changed = true
+    }
+  }
+  return changed
+}

package/src/LowCodeController.ts

@@ -0,0 +1,88 @@
+import { Request, Response } from "express"
+import { Build, GenericController, GenericService } from "./GenericController"
+import { handleError, Log } from "./http"
+import { ErrorMessage } from "./metadata"
+import { resources, StringMap } from "./resources"
+import { buildArray, Filter, format, fromRequest, getMetadataFunc, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult } from "./search"
+
+export interface Service<T, ID, R, S extends Filter> extends GenericService<T, ID, R> {
+  search: (s: S, limit: number, page?: number | string, fields?: string[]) => Promise<SearchResult<T>>
+}
+export class LowcodeController<T, ID, S extends Filter> extends GenericController<T, ID> {
+  config?: SearchConfig
+  csv?: boolean
+  dates?: string[]
+  numbers?: string[]
+  excluding?: string
+  array?: string[]
+  constructor(
+    public lowCodeService: Service<T, ID, number | ErrorMessage[], S>,
+    config?: SearchConfig,
+    build?: Build<T>,
+    validate?: (obj: T, resource?: StringMap, patch?: boolean) => Promise<ErrorMessage[]>,
+    dates?: string[],
+    numbers?: string[],
+  ) {
+    super(lowCodeService, build, validate)
+    this.search = this.search.bind(this)
+    this.config = initializeConfig(config)
+    if (this.config) {
+      this.csv = this.config.csv
+      this.excluding = this.config.excluding
+    }
+    const m = getMetadataFunc(lowCodeService, dates, numbers)
+    if (m) {
+      this.dates = m.dates
+      this.numbers = m.numbers
+    }
+  }
+  search(req: Request, res: Response) {
+    const s = fromRequest<S>(req, buildArray(this.array, resources.fields, this.excluding))
+    const l = getParameters(s)
+    const s2 = format(s, this.dates, this.numbers)
+    this.lowCodeService
+      .search(s2, l.limit, l.pageOrNextPageToken, l.fields)
+      .then((result) => jsonResult(res, result, this.csv, l.fields, this.config))
+      .catch((err) => handleError(err, res))
+  }
+}
+export { LowcodeController as LowcodeHandler }
+export class Controller<T, ID, S extends Filter> extends GenericController<T, ID> {
+  config?: SearchConfig
+  csv?: boolean
+  dates?: string[]
+  numbers?: string[]
+  excluding?: string
+  array?: string[]
+  constructor(
+    log: Log,
+    public lowCodeService: Service<T, ID, number | T | ErrorMessage[], S>,
+    build?: Build<T>,
+    validate?: (obj: T, resource?: StringMap, patch?: boolean) => Promise<ErrorMessage[]>,
+    config?: SearchConfig,
+    dates?: string[],
+    numbers?: string[],
+  ) {
+    super(lowCodeService, build, validate)
+    this.search = this.search.bind(this)
+    this.config = initializeConfig(config)
+    if (this.config) {
+      this.csv = this.config.csv
+      this.excluding = this.config.excluding
+    }
+    const m = getMetadataFunc(lowCodeService, dates, numbers)
+    if (m) {
+      this.dates = m.dates
+      this.numbers = m.numbers
+    }
+  }
+  search(req: Request, res: Response) {
+    const s = fromRequest<S>(req, buildArray(this.array, resources.fields, this.excluding))
+    const l = getParameters(s)
+    const s2 = format(s, this.dates, this.numbers)
+    this.lowCodeService
+      .search(s2, l.limit, l.pageOrNextPageToken, l.fields)
+      .then((result) => jsonResult(res, result, this.csv, l.fields, this.config))
+      .catch((err) => handleError(err, res))
+  }
+}

package/src/SearchController.ts

@@ -1,28 +1,39 @@
-import {Request, Response} from 'express';
-import {handleError} from './response';
-import {fromRequest, getLimit, initializeConfig, jsonResult, SearchConfig, SearchModel, SearchResult} from './search';
+import { Request, Response } from "express"
+import { handleError, Log } from "./http"
+import { resources } from "./resources"
+import { buildArray, Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult } from "./search"
 
-export class SearchController<T, S extends SearchModel> {
-  config?: SearchConfig;
-  csv?: boolean;
-  constructor(protected log: (msg: any, ctx?: any) => void, public find: (s: S, limit?: number, skip?: number, refId?: string) => Promise<SearchResult<T>>, config?: SearchConfig|boolean, public format?: (s: S) => S) {
-    this.search = this.search.bind(this);
+export class SearchController<T, S extends Filter> {
+  config?: SearchConfig
+  csv?: boolean
+  excluding?: string
+  array?: string[]
+  constructor(
+    protected log: Log,
+    public find: (s: S, limit: number, page?: number | string, fields?: string[]) => Promise<SearchResult<T>>,
+    config?: SearchConfig | boolean,
+    public dates?: string[],
+    public numbers?: string[],
+  ) {
+    this.search = this.search.bind(this)
     if (config) {
-      if (typeof config === 'boolean') {
-        this.csv = config;
+      if (typeof config === "boolean") {
+        this.csv = config
       } else {
-        this.config = initializeConfig(config);
+        this.config = initializeConfig(config)
         if (this.config) {
-          this.csv = this.config.csv;
+          this.csv = this.config.csv
+          this.excluding = this.config.excluding
         }
       }
     }
   }
   search(req: Request, res: Response) {
-    const s = fromRequest<S>(req, this.format);
-    const l = getLimit(s);
-    this.find(s, l.limit, l.skip, l.refId)
-      .then(result => jsonResult(res, result, this.csv, s.fields, this.config))
-      .catch(err => handleError(err, res, this.log));
+    const s = fromRequest<S>(req, buildArray(this.array, resources.fields, this.excluding))
+    const l = getParameters(s)
+    const s2 = format(s, this.dates, this.numbers)
+    this.find(s2, l.limit, l.pageOrNextPageToken, l.fields)
+      .then((result) => jsonResult(res, result, this.csv, l.fields, this.config))
+      .catch((err) => handleError(err, res))
   }
 }

package/src/access.ts

@@ -0,0 +1,42 @@
+import { NextFunction, Request, Response } from "express"
+
+export interface AccessConfig {
+  origin?: string | string[]
+  credentials?: string | string[]
+  methods?: string | string[]
+  headers: number | string | ReadonlyArray<string>
+}
+export type AccessControlAllowConfig = AccessConfig
+export function allow(
+  access: AccessConfig,
+): (req: Request, res: Response, next: NextFunction) => void {
+  const ao = access.origin
+  if (typeof ao === "string") {
+    return (req: Request, res: Response, next: NextFunction) => {
+      res.header("Access-Control-Allow-Origin", access.origin)
+      res.header("Access-Control-Allow-Credentials", access.credentials)
+      res.header("Access-Control-Allow-Methods", access.methods)
+      res.setHeader("Access-Control-Allow-Headers", access.headers)
+      next()
+    }
+  } else if (Array.isArray(ao) && ao.length > 0) {
+    return (req: Request, res: Response, next: NextFunction) => {
+      const origin = req.headers.origin
+      if (origin) {
+        if (ao.includes(origin)) {
+          res.setHeader("Access-Control-Allow-Origin", origin)
+        }
+      }
+      res.header("Access-Control-Allow-Credentials", access.credentials)
+      res.header("Access-Control-Allow-Methods", access.methods)
+      res.setHeader("Access-Control-Allow-Headers", access.headers)
+      next()
+    }
+  }
+  return (req: Request, res: Response, next: NextFunction) => {
+    res.header("Access-Control-Allow-Credentials", access.credentials)
+    res.header("Access-Control-Allow-Methods", access.methods)
+    res.setHeader("Access-Control-Allow-Headers", access.headers)
+    next()
+  }
+}

package/src/client.ts

@@ -0,0 +1,69 @@
+import * as http from "http"
+import * as https from "https"
+import { AnyMap, HealthChecker } from "./health"
+
+function getHealthSecure(url: string, timeout: number): Promise<AnyMap> {
+  return new Promise((resolve) => {
+    https
+      .get(url, { rejectUnauthorized: false }, (res: any) => {
+        let data = ""
+        res.on("data", (d: any) => {
+          data += d
+        })
+        res.on("end", () => {
+          resolve({ statusCode: res.statusCode, data, statusMessage: res.statusMessage })
+        })
+      })
+      .on("error", (e: any) => {
+        return { statusCode: 500, statusMessage: e }
+      })
+    setTimeout(() => resolve({ statusCode: 408, statusMessage: "Time out" }), timeout)
+  })
+}
+function getHealth(url: string, timeout: number): Promise<AnyMap> {
+  return new Promise((resolve) => {
+    http
+      .get(url, (res: any) => {
+        let data = ""
+        res.on("data", (d: any) => {
+          data += d
+        })
+        res.on("end", () => {
+          resolve({ statusCode: res.statusCode, data, statusMessage: res.statusMessage })
+        })
+      })
+      .on("error", (e: any) => {
+        return { statusCode: 500, statusMessage: e }
+      })
+    setTimeout(() => resolve({ statusCode: 408, statusMessage: "Time out" }), timeout)
+  })
+}
+export class ClientChecker implements HealthChecker {
+  timeout: number
+  constructor(private service: string, private url: string, timeout: number) {
+    this.timeout = timeout ? timeout : 4200
+    this.check = this.check.bind(this)
+    this.name = this.name.bind(this)
+    this.build = this.build.bind(this)
+  }
+  check(): Promise<AnyMap> {
+    let obj = {} as AnyMap
+    if (this.url.startsWith("https://")) {
+      return getHealthSecure(this.url, this.timeout).then((r) => (obj = r))
+    } else {
+      return getHealth(this.url, this.timeout).then((r) => (obj = r))
+    }
+  }
+  name(): string {
+    return this.service
+  }
+  build(data: AnyMap, err: any): AnyMap {
+    if (err) {
+      if (!data) {
+        data = {} as AnyMap
+      }
+      data["error"] = err
+    }
+    return data
+  }
+}