fa-consul 1.0.1

package/src/interfaces.ts

@@ -0,0 +1,276 @@
+import EventEmitter from 'events';
+
+import { AccessPoints } from './access-points/access-points';
+import { RegisterCheck, ConsulClientOptions } from './consul-client';
+
+export type Maybe<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type TBooleanLike = 'true' | 'false' | 'yes' | 'no' | '1' | '0' | 1 | 0;
+
+export interface ISocketInfo {
+  host: string;
+  port: string | number;
+}
+
+export interface IRegisterCheck extends RegisterCheck {
+  name?: string;
+  tcp?: string;
+  dockercontainerid?: string;
+  shell?: string;
+  timeout?: string;
+  deregistercriticalserviceafter?: string;
+}
+
+export interface IRegisterConfig {
+  id: string;
+  name: string;
+  tags?: string[];
+  address?: string;
+  port?: number;
+  meta?: Record<string, string>;
+  check?: IRegisterCheck;
+  checks?: IRegisterCheck[];
+  connect?: any;
+  proxy?: any;
+  taggedAddresses?: any;
+}
+
+export type TRegisterType = 'if-not-registered' | 'if-config-differ' | 'force';
+
+export interface IRegisterOptions {
+  registerType?: TRegisterType,
+  deleteOtherInstance?: boolean,
+  noAlreadyRegisteredMessage?: boolean,
+}
+
+export type TRegisterResult = 'already' | 'just' | false;
+
+export interface IConsulAgentOptions extends ConsulClientOptions {
+  host: string;
+  port: string;
+  dc?: string | undefined;
+  defaults?: { token?: string | undefined } | undefined;
+}
+
+export interface IFullConsulAgentOptions {
+  reg: IConsulAgentOptions,
+  dev: IConsulAgentOptions,
+  prd: IConsulAgentOptions
+}
+
+export type TLoggerMethod = (...args: unknown[]) => any;
+
+export interface ILogger {
+  silly: TLoggerMethod;
+  debug: TLoggerMethod;
+  info: TLoggerMethod;
+  warn: TLoggerMethod;
+  error: TLoggerMethod;
+}
+
+export interface IMeta {
+  [prop: string]: Nullable<string | number | boolean>,
+}
+
+export interface IAccessPoint {
+  consulServiceName: string,
+  id?: string,
+  title?: string,
+  port?: number | null,
+  host?: string | null,
+  setProps?: (data: Record<string, any> | null) => IAccessPoint | undefined,
+  isAP?: true,
+  meta?: IMeta | undefined,
+  isReachable?: boolean,
+  lastSuccessUpdate?: number,
+  idHostPortUpdated?: boolean,
+  getChanges?: () => [string, any, any][] | undefined,
+  updateIntervalIfSuccessMillis?: number,
+  noConsul?: boolean,
+  retrieveProps?: (host: string, meta?: any) => { host: string; port: number | null | undefined },
+
+  [propName: string]: any
+}
+
+export interface IAccessPointsMethods {
+  addAP?: (apKey: string, apData: any) => IAccessPoint | undefined,
+  setAP?: (apKey: string, apData: Record<string, any> | null) => IAccessPoint | undefined,
+  getAP?: (accessPointKey: string, andNotIsAP?: boolean) => IAccessPoint | undefined,
+  get?: (accessPointKey?: string, andNotIsAP?: boolean) => { [apKey: string]: IAccessPoint } | IAccessPoint | undefined,
+}
+
+export type IAccessPoints = {
+  [apKey: string]: IAccessPoint,
+} & IAccessPointsMethods
+
+export interface IConsulAgentConfig {
+  host?: string, // || FQDN || env.HOST_HOSTNAME || config.consul.service?.host || '127.0.0.1'
+  port?: string, // || 8500
+  secure?: string | TBooleanLike | boolean,
+  token?: string,
+  dc?: string;
+}
+
+export interface IFullConsulAgentConfig {
+  reg: IConsulAgentConfig,
+  dev?: IConsulAgentConfig,
+  prd?: IConsulAgentConfig
+}
+
+export interface IAFConsulConfig {
+  agent: IFullConsulAgentConfig,
+  check?: IRegisterCheck,
+  service: {
+    id?: string,
+    name: string,
+    instance: string,
+    version: string,
+    description: string,
+    tags?: string | string[],
+    meta?: string | IMeta,
+    host?: Nullable<string>,
+    port?: Nullable<string | number>
+    /**
+     * if false - disable the registration of the service with the consul
+     * Does not affect anything directly in this package and should be used where the package is imported
+     */
+    enable?: boolean,
+    /**
+     * @deprecated use `enable` instead
+     * if true - disable the registration of the service with the consul.
+     * For backward compatibility, has an increased priority of enable.
+     *
+     * Does not affect anything directly in this package and should be used where the package is imported
+     */
+    noRegOnStart?: boolean,
+  },
+}
+
+export interface IAFConfig {
+  accessPoints?: IAccessPoints | AccessPoints,
+  consul: IAFConsulConfig,
+  webServer: any,
+  service?: {
+    id?: string,
+    address?: string,
+    fromService?: string,
+  };
+}
+
+export type TCommonFnResult = any;
+
+type TMethod<T> = (...args: any[]) => T;
+
+export interface ICLOptions {
+  config: IAFConfig,
+  logger?: ILogger,
+  em?: EventEmitter,
+
+  envCode?: string,
+  getConsulUIAddress?: TMethod<string>,
+  hash?: string,
+}
+
+export interface IConsulServiceInfo {
+  ID: string,
+  Service: string,
+  Tags?: string[],
+  Meta?: IMeta,
+  Port: number,
+  Address: string,
+  Weights?: { Passing: number, Warning: number },
+  EnableTagOverride?: boolean,
+  Datacenter?: string,
+
+  // Service attributes
+  Proxy?: object, // { MeshGateway: {}, Expose: {} }
+  Connect?: object, // { MeshGateway: {}, Expose: {} }
+  CreateIndex?: number,
+  ModifyIndex?: number,
+
+  [prop: string]: any,
+}
+
+export interface IConsulNodeInfo {
+  ID: string,
+  Node?: string,
+  Address: string,
+  Datacenter?: string,
+  TaggedAddresses?: object, // { lan: <ip>, lan_ipv4: <ip>, wan: <ip>, wan_ipv4: <ip> }
+  Meta?: IMeta,
+  CreateIndex?: number,
+  ModifyIndex?: number,
+}
+
+export interface IConsulHealthServiceInfo {
+  Node?: IConsulNodeInfo,
+  Service?: IConsulServiceInfo,
+  Checks?: any[]
+}
+
+export interface IAPIArgs {
+  agentOptions?: IConsulAgentOptions | undefined,
+  options?: any;
+  withError?: boolean;
+  result?: any;
+  agentType?: keyof IFullConsulAgentConfig | undefined;
+}
+
+export interface IConsulAPI {
+  agentServiceList: (apiArgs?: IAPIArgs) => Promise<{ [serviceName: string]: IConsulServiceInfo }>,
+
+  catalogServiceList (dc: string, apiArgs?: IAPIArgs): Promise<{ [serviceId: string]: string[] }>,
+
+  consulHealthService: (apiArgs: IAPIArgs) => Promise<IConsulHealthServiceInfo[]>,
+  getServiceInfo: (serviceName: string) => Promise<IConsulServiceInfo | undefined>,
+  getServiceSocket: (serviceName: string, defaults: ISocketInfo) => Promise<ISocketInfo>,
+  agentServiceRegister: (options: IRegisterConfig, withError?: boolean) => Promise<boolean>,
+  agentServiceDeregister: (serviceId: string, apiArgs?: IAPIArgs) => Promise<boolean>,
+  deregisterIfNeed: (serviceId: string, agentOptions?: IConsulAgentOptions) => Promise<boolean>,
+  agentMembers: (apiArgs?: IAPIArgs) => Promise<TCommonFnResult>,
+  checkIfServiceRegistered: (serviceIdOrName: string, apiArgs?: IAPIArgs) => Promise<IConsulHealthServiceInfo | undefined>,
+  registerService: (registerConfig: IRegisterConfig, registerOptions: IRegisterOptions) => Promise<TRegisterResult>,
+
+  agentOptions: IFullConsulAgentOptions,
+  getConsulAgentOptions: (clOptions: ICLOptions) => Promise<IFullConsulAgentOptions>,
+}
+
+export interface ICyclicStartArgs {
+  cLOptions?: ICLOptions,
+  registerInterval?: number,
+  registerType?: TRegisterType,
+  deleteOtherInstance?: boolean,
+  noAlreadyRegisteredMessage?: boolean,
+}
+
+export interface IRegisterCyclic {
+  isStarted: boolean,
+  skipNextRegisterAttemptUntil: number,
+  healthCheckIntervalMillis: number,
+  registerIntervalMillis: number,
+  options: ICLOptions,
+  _timerId: ReturnType<typeof setTimeout>,
+  _logger: ILogger,
+
+  start: (cyclicStartArgs?: ICyclicStartArgs) => Promise<-1 | 0 | 1>
+  stop: () => void
+}
+
+export interface IAFConsulAPI extends IConsulAPI {
+  registerConfig: IRegisterConfig,
+  getConsulUIAddress: TMethod<string>,
+  serviceId: string,
+  register: {
+    once: (registerType?: TRegisterType) => Promise<TRegisterResult>,
+    cyclic: IRegisterCyclic,
+  }
+  deregister: (svcId?: string, agentHost?: string, agentPort?: string) => Promise<boolean>
+  consulUI?: string,
+}
+
+export interface ICache<T> {
+  [hash: string]: {
+    created: number,
+    value: T
+  }
+}

package/src/lib/color.ts

@@ -0,0 +1,43 @@
+// noinspection JSUnusedGlobalSymbols
+
+export const reset = '\x1b[0m';
+export const rs = reset;
+export const clear = '\x1b[K';
+export const bold = '\x1b[1m';
+export const boldOff = '\x1b[21m';
+export const italics = '\x1b[3m';
+export const italicsOff = '\x1b[23m';
+export const def = '\x1b[39m';
+
+export const white = '\x1b[37m';
+export const w = white;
+export const black = '\x1b[30m';
+export const bk = black;
+export const red = '\x1b[31m';
+export const r = red;
+export const green = '\x1b[32m';
+export const g = green;
+export const yellow = '\x1b[33m';
+export const y = yellow;
+export const blue = '\x1b[34m';
+export const b = blue;
+export const magenta = '\x1b[35m';
+export const m = magenta;
+export const cyan = '\x1b[36m';
+export const c = cyan;
+
+export const lWhite = '\x1b[97m';
+export const lw = lWhite;
+export const lGray = '\x1b[90m';
+export const lRed = '\x1b[91m';
+export const lr = lRed;
+export const lGreen = '\x1b[92m';
+export const lg = lGreen;
+export const lYellow = '\x1b[93m';
+export const ly = lYellow;
+export const lBlue = '\x1b[94m';
+export const lb = lBlue;
+export const lMagenta = '\x1b[95m';
+export const lm = lMagenta;
+export const lCyan = '\x1b[96m';
+export const lc = lCyan;

package/src/lib/curl-text.ts

@@ -0,0 +1,91 @@
+import { RequestInfo } from '../consul-client';
+
+class ToCurl {
+  private readonly request: {
+    method: string;
+    headers: Record<string, string>;
+    url: string;
+    params?: Record<string, string | boolean | undefined> | undefined;
+    data?: unknown;
+  };
+
+  constructor (req: RequestInfo) {
+    let data: unknown;
+    if (req.body) {
+      try {
+        data = JSON.parse(req.body);
+      } catch {
+        data = req.body;
+      }
+    }
+    this.request = {
+      method: req.method,
+      headers: req.headers,
+      url: req.url.split('?')[0] || req.url,
+      ...(req.query ? { params: req.query } : {}),
+      ...(data !== undefined ? { data } : {}),
+    };
+  }
+
+  getHeaders () {
+    const { headers } = this.request;
+    let curlHeaders = '';
+
+    Object.keys(headers).forEach((property) => {
+      if ({}.hasOwnProperty.call(headers, property)) {
+        if (property !== 'content-length' && property !== 'Content-Length') {
+          curlHeaders += ` -H "${property}:${headers[property]}"`;
+        }
+      }
+    });
+
+    return curlHeaders.trim();
+  }
+
+  getMethod () {
+    return `-X ${this.request.method.toUpperCase()}`;
+  }
+
+  getBody () {
+    const r = this.request;
+    const { data } = r;
+    if (
+      typeof data !== 'undefined'
+      && data !== ''
+      && data !== null
+      && r.method.toUpperCase() !== 'GET'
+    ) {
+      const d = typeof data === 'object' || Object.prototype.toString.call(data) === '[object Array]'
+        ? JSON.stringify(data, undefined, 2)
+        : data;
+      return `--data '${d}'`;
+    }
+    return '';
+  }
+
+  getUrl () {
+    return this.request.url;
+  }
+
+  getQueryString () {
+    const { params } = this.request;
+    if (!params) {return '';}
+
+    return Object.keys(params)
+      .filter((param) => params[param] !== undefined && params[param] !== '')
+      .reduce((qs, param) => `${qs}${qs ? '&' : '?'}${param}=${params[param]}`, '');
+  }
+
+  getBuiltURL () {
+    return (this.getUrl() + this.getQueryString()).trim();
+  }
+
+  getCURL () {
+    return `curl -i ${this.getMethod()} "${this.getBuiltURL()}" ${this.getHeaders()} ${this.getBody()}`;
+  }
+}
+
+export const getCurlText = (req: RequestInfo) => {
+  const instance = new ToCurl(req);
+  return instance.getCURL();
+};

package/src/lib/fqdn.ts

@@ -0,0 +1,45 @@
+import * as dns from 'dns';
+import * as os from 'os';
+
+import { ICache } from '../interfaces';
+
+import { minimizeCache } from './utils';
+
+// Returns fully qualified domain name
+export const getFQDN = (h?: string, withError?: boolean, onlyDomain?: boolean): Promise<string | null> => {
+  h = h || os.hostname();
+  return new Promise((resolve, reject) => {
+    dns.lookup(h as string, { hints: dns.ADDRCONFIG }, (err: any, ip: string) => {
+      if (err) {
+        return withError ? reject(err) : resolve(null);
+      }
+      dns.lookupService(ip, 0, (err2, hostname) => {
+        if (err2) {
+          return withError ? reject(err2) : resolve(null);
+        }
+        if (onlyDomain && !/\.[a-z]+$/i.test(hostname)) {
+          resolve(null);
+          return;
+        }
+        resolve(hostname);
+      });
+    });
+  });
+};
+
+const fqdnCache: ICache<string> = {};
+
+export const getFQDNCached = async (...args: any[]): Promise<string | null> => {
+  const hostNameOrIP = args[0] || os.hostname() || '-';
+  minimizeCache(fqdnCache, 10);
+  if (!fqdnCache[hostNameOrIP]) {
+    const fqdn = await getFQDN(...args);
+    if (fqdn) {
+      fqdnCache[hostNameOrIP] = {
+        created: Date.now(),
+        value: fqdn,
+      };
+    }
+  }
+  return fqdnCache[hostNameOrIP]?.value || null;
+};

package/src/lib/hash.ts

@@ -0,0 +1,56 @@
+import { pick } from 'af-tools-ts';
+import * as XXH from 'xxhashjs';
+
+import { IAFConfig, ICLOptions } from '../interfaces';
+
+import { isObject } from './utils';
+
+const getHash = (data: any, base: '32' | '64' = '32', seed: number = 0xCAFEBABE) => {
+  let stringToHash = '';
+  if (data === undefined) {
+    stringToHash = '#thisisundefined#';
+  } else if (data === null) {
+    stringToHash = '#thisisnull#';
+  } else if (data === '') {
+    stringToHash = '#thisisemptystring#';
+  } else if (Array.isArray(data)) {
+    const arr = data.map((value) => ([value, getHash(String(value) + (typeof value), '32', seed)]));
+    arr.sort(([, a], [, b]) => {
+      if (a < b) {return -1;}
+      if (a > b) {return 1;}
+      return 0;
+    });
+    stringToHash = JSON.stringify(arr.map(([v]) => v));
+  } else if (isObject(data)) {
+    const op = Object.prototype.toString.call(data); // === '[object Date]'
+    switch (op) {
+      case '[object Function]':
+      case '[object Date]':
+        stringToHash += data.toString();
+        break;
+      // case '[object Object]':
+      default: {
+        const keys = Object.keys(data).sort();
+        keys.forEach((key) => {
+          stringToHash += key + getHash(data[key], base, seed);
+        });
+      }
+    }
+  } else if (typeof data === 'string') {
+    stringToHash = data;
+  } else if (typeof data === 'number') {
+    stringToHash = `i${String(data)}`;
+  } else if (typeof data === 'boolean') {
+    stringToHash = `b${data ? 1 : 0}`;
+  } else if (typeof data === 'function') {
+    stringToHash = `f${data.toString()}`;
+  }
+  return XXH[`h${base}`](stringToHash, seed).toString(16);
+};
+
+export const getConfigHash = (options: ICLOptions): string => {
+  const opt = pick(options.config, ['consul', 'webServer']) as IAFConfig;
+  const hash = getHash(opt);
+  options.hash = hash;
+  return hash;
+};

package/src/lib/http-request-text.ts

@@ -0,0 +1,24 @@
+import { RequestInfo } from '../consul-client';
+
+const getHttpRequestText = (request: RequestInfo) => {
+  const { hostname, port, path, method, headers, body } = request;
+  let res = `###\n${method} ${request.protocol}//${hostname}${port ? `:${port}` : ''}${path}`;
+
+  Object.entries(headers)
+    .forEach(([headerName, value]) => {
+      if (headerName !== 'content-length' && headerName !== 'Content-Length') {
+        res += `\n${headerName}: ${value}`;
+      }
+    });
+
+  if ((method === 'POST' || method === 'PUT') && body) {
+    try {
+      res += `\n\n${JSON.stringify(JSON.parse(body), undefined, 2)}`;
+    } catch {
+      res += `\n\n${body}`;
+    }
+  }
+  return res;
+};
+
+export default getHttpRequestText;

package/src/lib/logger-stub.ts

@@ -0,0 +1,11 @@
+/* eslint-disable no-console */
+
+const loggerStub = {
+  silly: console.log,
+  debug: console.log,
+  info: console.log,
+  warn: console.log,
+  error: console.log,
+};
+
+export default loggerStub;