@brimble/consul 0.0.1

package/lib/catalog.js

@@ -0,0 +1,113 @@
+const CatalogConnect = require("./catalog/connect").CatalogConnect;
+const CatalogNode = require("./catalog/node").CatalogNode;
+const CatalogService = require("./catalog/service").CatalogService;
+const utils = require("./utils");
+const errors = require("./errors");
+
+class Catalog {
+  constructor(consul) {
+    this.consul = consul;
+
+    this.connect = new Catalog.Connect(consul);
+    this.node = new Catalog.Node(consul);
+    this.service = new Catalog.Service(consul);
+  }
+
+  /**
+   * Lists known datacenters
+   */
+  async datacenters(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.datacenters",
+      path: "/catalog/datacenters",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Lists nodes in a given DC
+   */
+  nodes(...args) {
+    return this.node.list(...args);
+  }
+
+  /**
+   * Registers or updates entries in the catalog
+   */
+  async register(opts) {
+    if (typeof opts === "string") {
+      opts = { node: opts, address: "127.0.0.1" };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.register",
+      path: "/catalog/register",
+      type: "json",
+      body: {},
+    };
+
+    if (!opts.node || !opts.address) {
+      throw this.consul._err(
+        errors.Validation("node and address required"),
+        req,
+      );
+    }
+
+    req.body = utils.createCatalogRegistration(opts);
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Deregister entries in the catalog
+   */
+  async deregister(opts) {
+    if (typeof opts === "string") {
+      opts = { node: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.deregister",
+      path: "/catalog/deregister",
+      type: "json",
+      body: {},
+    };
+
+    if (!opts.node) {
+      throw this.consul._err(errors.Validation("node required"), req);
+    }
+
+    req.body = utils.createCatalogDeregistration(opts);
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Lists services in a given DC
+   */
+  services(...args) {
+    return this.service.list(...args);
+  }
+}
+
+Catalog.Connect = CatalogConnect;
+Catalog.Node = CatalogNode;
+Catalog.Service = CatalogService;
+
+exports.Catalog = Catalog;

package/lib/constants.js

@@ -0,0 +1,21 @@
+exports.DEFAULT_OPTIONS = [
+  "consistent",
+  "dc",
+  "partition",
+  "stale",
+  "timeout",
+  "token",
+  "wait",
+  "wan",
+];
+
+exports.AGENT_STATUS = ["none", "alive", "leaving", "left", "failed"];
+
+exports.CHECK_STATE = ["unknown", "passing", "warning", "critical"];
+
+const du = (exports.DURATION_UNITS = { ns: 1 });
+du.us = 1000 * du.ns;
+du.ms = 1000 * du.us;
+du.s = 1000 * du.ms;
+du.m = 60 * du.s;
+du.h = 60 * du.m;

package/lib/consul.d.ts

@@ -0,0 +1,93 @@
+import { Agent as httpAgent } from "http";
+import { Agent as httpsAgent } from "https";
+import { Acl } from "./acl";
+import { Agent } from "./agent";
+import { Catalog } from "./catalog";
+import { Event } from "./event";
+import { Health } from "./health";
+import { Intention } from "./intention";
+import { Kv } from "./kv";
+import { Query } from "./query";
+import {
+  Resolver,
+  ConsulResolverConfig,
+  SelectionAlgorithm,
+  ServiceInfo,
+  OptimalServiceResult,
+  ServiceMetrics,
+} from "./resolver";
+import { Session } from "./session";
+import { Status } from "./status";
+import { Transaction } from "./transaction";
+import { Watch, WatchOptions } from "./watch";
+
+export interface CommonOptions {
+  token?: string;
+}
+
+interface DefaultOptions extends CommonOptions {
+  dc?: string;
+  partition?: string;
+  wan?: boolean;
+  consistent?: boolean;
+  stale?: boolean;
+  index?: string;
+  wait?: string;
+  near?: string;
+  filter?: string;
+}
+
+interface ConsulOptions {
+  host?: string;
+  port?: number;
+  secure?: boolean;
+  defaults?: DefaultOptions;
+  agent?: httpAgent | httpsAgent;
+}
+
+declare class Consul {
+  constructor(options?: ConsulOptions);
+
+  acl: Acl;
+  agent: Agent;
+  catalog: Catalog;
+  event: Event;
+  health: Health;
+  intention: Intention;
+  kv: Kv;
+  query: Query;
+  session: Session;
+  status: Status;
+  transaction: Transaction;
+
+  static Acl: typeof Acl;
+  static Agent: typeof Agent;
+  static Catalog: typeof Catalog;
+  static Event: typeof Event;
+  static Health: typeof Health;
+  static Intention: typeof Intention;
+  static Kv: typeof Kv;
+  static Query: typeof Query;
+  static Resolver: typeof Resolver;
+  static Session: typeof Session;
+  static Status: typeof Status;
+  static Transaction: typeof Transaction;
+  static Watch: typeof Watch;
+
+  destroy(): void;
+
+  watch(options: WatchOptions): Watch;
+
+  resolver(config: ConsulResolverConfig): Resolver;
+}
+
+export {
+  SelectionAlgorithm,
+  ConsulResolverConfig,
+  ServiceInfo,
+  OptimalServiceResult,
+  ServiceMetrics,
+  Resolver,
+};
+
+export { Consul };

package/lib/consul.js

@@ -0,0 +1,98 @@
+const papi = require("papi");
+
+const Acl = require("./acl").Acl;
+const Agent = require("./agent").Agent;
+const Catalog = require("./catalog").Catalog;
+const Event = require("./event").Event;
+const Health = require("./health").Health;
+const Intention = require("./intention").Intention;
+const Kv = require("./kv").Kv;
+const Query = require("./query").Query;
+const Resolver = require("./resolver").Resolver;
+const Session = require("./session").Session;
+const Status = require("./status").Status;
+const Watch = require("./watch").Watch;
+const Transaction = require("./transaction").Transaction;
+const utils = require("./utils");
+
+class Consul extends papi.Client {
+  constructor(opts) {
+    opts = utils.defaults({}, opts);
+
+    if (!opts.baseUrl) {
+      opts.baseUrl =
+        (opts.secure ? "https:" : "http:") +
+        "//" +
+        (opts.host || "127.0.0.1") +
+        ":" +
+        (opts.port || 8500) +
+        "/v1";
+    }
+    opts.name = "consul";
+    opts.type = "json";
+
+    let agent;
+    if (!opts.agent) {
+      agent = utils.getAgent(opts.baseUrl);
+      if (agent) {
+        opts.agent = agent;
+      }
+    }
+
+    let defaults;
+    if (opts.defaults) {
+      defaults = utils.defaultCommonOptions(opts.defaults);
+    }
+    delete opts.defaults;
+
+    super(opts);
+
+    if (defaults) this._defaults = defaults;
+
+    this.acl = new Consul.Acl(this);
+    this.agent = new Consul.Agent(this);
+    this.catalog = new Consul.Catalog(this);
+    this.event = new Consul.Event(this);
+    this.health = new Consul.Health(this);
+    this.intention = new Consul.Intention(this);
+    this.kv = new Consul.Kv(this);
+    this.query = new Consul.Query(this);
+    this.session = new Consul.Session(this);
+    this.status = new Consul.Status(this);
+    this.transaction = new Consul.Transaction(this);
+  }
+
+  destroy() {
+    if (this._opts.agent && this._opts.agent.destroy) {
+      this._opts.agent.destroy();
+    }
+  }
+
+  watch(opts) {
+    return new Consul.Watch(this, opts);
+  }
+
+  resolver(config) {
+    return new Consul.Resolver(this, config);
+  }
+
+  static parseQueryMeta(res) {
+    return utils.parseQueryMeta(res);
+  }
+}
+
+Consul.Acl = Acl;
+Consul.Agent = Agent;
+Consul.Catalog = Catalog;
+Consul.Event = Event;
+Consul.Health = Health;
+Consul.Intention = Intention;
+Consul.Kv = Kv;
+Consul.Query = Query;
+Consul.Resolver = Resolver;
+Consul.Session = Session;
+Consul.Status = Status;
+Consul.Transaction = Transaction;
+Consul.Watch = Watch;
+
+exports.Consul = Consul;

package/lib/errors.js

@@ -0,0 +1,29 @@
+"use strict";
+
+/**
+ * Create error
+ */
+function create(message) {
+  const error =
+    message instanceof Error
+      ? message
+      : new Error(message ? message : undefined);
+
+  error.isConsul = true;
+
+  return error;
+}
+
+/**
+ * Create validation error
+ */
+function validation(message) {
+  const error = create(message);
+
+  error.isValidation = true;
+
+  return error;
+}
+
+exports.Consul = create;
+exports.Validation = validation;

package/lib/event.d.ts

@@ -0,0 +1,43 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface FireOptions extends CommonOptions {
+  name: string;
+  payload: string | Buffer;
+  dc?: string;
+  node?: string;
+  service?: string;
+  tag?: string;
+}
+
+interface FireResult {
+  ID: string;
+  Name: string;
+  Payload: string;
+  NodeFilter: string;
+  ServiceFilter: string;
+  TagFilter: string;
+  Version: number;
+  LTime: number;
+}
+
+interface ListOptions extends CommonOptions {
+  name?: string;
+  node?: string;
+  service?: string;
+  tag?: string;
+}
+
+type ListResult = FireResult[];
+
+declare class Event {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  fire(name: string): Promise<FireResult>;
+  fire(name: string, payload: string | Buffer): Promise<FireResult>;
+  fire(options: FireOptions): Promise<FireResult>;
+
+  list(options?: ListOptions): Promise<ListResult>;
+  list(name: string): Promise<ListResult>;
+}

package/lib/event.js

@@ -0,0 +1,91 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Event {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Fires a new user event
+   */
+  async fire(opts) {
+    let options;
+    if (arguments.length === 2) {
+      options = {
+        name: arguments[0],
+        payload: arguments[1],
+      };
+    } else if (typeof opts === "string") {
+      options = { name: opts };
+    } else {
+      options = opts;
+    }
+
+    options = utils.normalizeKeys(options);
+    options = utils.defaults(options, this.consul._defaults);
+
+    const req = {
+      name: "event.fire",
+      path: "/event/fire/{name}",
+      params: { name: options.name },
+      query: {},
+    };
+
+    if (!options.name) {
+      throw this.consul._err(errors.Validation("name required"), req);
+    }
+
+    let buffer;
+
+    if (options.hasOwnProperty("payload")) {
+      buffer = Buffer.isBuffer(options.payload);
+      req.body = buffer ? options.payload : Buffer.from(options.payload);
+    }
+    if (options.node) req.query.node = options.node;
+    if (options.service) req.query.service = options.service;
+    if (options.tag) req.query.tag = options.tag;
+
+    utils.options(req, options);
+
+    return await this.consul._put(req, utils.body).then((data) => {
+      if (data.hasOwnProperty("Payload")) {
+        data.Payload = utils.decode(data.Payload, { buffer: buffer });
+      }
+      return data;
+    });
+  }
+
+  /**
+   * Lists the most recent events an agent has seen
+   */
+  async list(opts) {
+    if (typeof opts === "string") {
+      opts = { name: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "event.list",
+      path: "/event/list",
+      query: {},
+    };
+
+    if (opts.name) req.query.name = opts.name;
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body).then((data) => {
+      data.forEach((item) => {
+        if (item.hasOwnProperty("Payload")) {
+          item.Payload = utils.decode(item.Payload, opts);
+        }
+      });
+      return data;
+    });
+  }
+}
+
+exports.Event = Event;

package/lib/health.d.ts

@@ -0,0 +1,77 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface NodeOptions extends CommonOptions {
+  name: string;
+  dc?: string;
+  filter?: string;
+  ns?: string;
+}
+
+interface Node {
+  ID: string;
+  Node: string;
+  CheckID: string;
+  Name: string;
+  Status: "passing" | "warning" | "critical";
+  Notes: string;
+  Output: string;
+  ServiceID: string;
+  ServiceName: string;
+  ServiceTags: string[];
+  Namespace: string;
+}
+
+type NodeResult = Node[];
+
+interface ChecksOptions extends CommonOptions {
+  service: string;
+  dc?: string;
+  near?: string;
+  filter?: string;
+  ns?: string;
+}
+
+type ChecksResult = Node[];
+
+interface ServiceOptions extends CommonOptions {
+  service: string;
+  dc?: string;
+  near?: string;
+  tag?: string;
+  passing?: boolean;
+  filter?: string;
+  peer?: string;
+  ns?: string;
+}
+
+type ServiceResult = any[];
+
+interface StateOptions extends CommonOptions {
+  state: "any" | "passing" | "warning" | "critical";
+  dc?: string;
+  near?: string;
+  filter?: string;
+  ns?: string;
+}
+
+type StateResult = Node[];
+
+declare class Health {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  node(options: NodeOptions): Promise<NodeResult>;
+  node(name: string): Promise<NodeResult>;
+
+  checks(options: ChecksOptions): Promise<ChecksResult>;
+  checks(service: string): Promise<ChecksResult>;
+
+  service(options: ServiceOptions): Promise<ServiceResult>;
+  service(service: string): Promise<ServiceResult>;
+
+  state(options: StateOptions): Promise<StateResult>;
+  state(
+    state: "any" | "passing" | "warning" | "critical",
+  ): Promise<StateResult>;
+}

package/lib/health.js

@@ -0,0 +1,126 @@
+const constants = require("./constants");
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Health {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Returns the health info of a node
+   */
+  async node(opts) {
+    if (typeof opts === "string") {
+      opts = { node: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "health.node",
+      path: "/health/node/{node}",
+      params: { node: opts.node },
+    };
+
+    if (!opts.node) {
+      throw this.consul._err(errors.Validation("node required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Returns the checks of a service
+   */
+  async checks(opts) {
+    if (typeof opts === "string") {
+      opts = { service: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "health.checks",
+      path: "/health/checks/{service}",
+      params: { service: opts.service },
+    };
+
+    if (!opts.service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Returns the nodes and health info of a service
+   */
+  async service(opts) {
+    if (typeof opts === "string") {
+      opts = { service: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "health.service",
+      path: "/health/service/{service}",
+      params: { service: opts.service },
+      query: {},
+    };
+
+    if (!opts.service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    if (opts.tag) req.query.tag = opts.tag;
+    if (opts.passing) req.query.passing = "true";
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Returns the checks in a given state
+   */
+  async state(opts) {
+    if (typeof opts === "string") {
+      opts = { state: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "health.state",
+      path: "/health/state/{state}",
+      params: { state: opts.state },
+    };
+
+    if (!opts.state) {
+      throw this.consul._err(errors.Validation("state required"), req);
+    }
+
+    if (opts.state !== "any" && constants.CHECK_STATE.indexOf(opts.state) < 0) {
+      throw this.consul._err(
+        errors.Validation("state invalid: " + opts.state),
+        req,
+      );
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+}
+
+exports.Health = Health;

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+import { Consul, SelectionAlgorithm } from "./consul";
+import {
+  ConsulResolverConfig,
+  ServiceInfo,
+  OptimalServiceResult,
+  ServiceMetrics,
+  Resolver,
+} from "./resolver";
+
+export = Consul;
+
+export type {
+  ConsulResolverConfig,
+  ServiceInfo,
+  OptimalServiceResult,
+  ServiceMetrics,
+};
+export { SelectionAlgorithm, Resolver };