@brimble/consul 0.0.1

package/lib/agent/service.js

@@ -0,0 +1,113 @@
+const errors = require("../errors");
+const utils = require("../utils");
+
+class AgentService {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Returns the services local agent is managing
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.service.list",
+      path: "/agent/services",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Registers a new local service
+   */
+  async register(opts) {
+    if (typeof opts === "string") {
+      opts = { name: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.service.register",
+      path: "/agent/service/register",
+      type: "json",
+      body: {},
+    };
+
+    if (!opts.name) {
+      throw this.consul._err(errors.Validation("name required"), req);
+    }
+
+    try {
+      req.body = utils.createService(opts);
+    } catch (err) {
+      throw this.consul._err(errors.Validation(err.message), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Deregister a local service
+   */
+  async deregister(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.service.deregister",
+      path: "/agent/service/deregister/{id}",
+      params: { id: opts.id },
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Manages node maintenance mode
+   */
+  async maintenance(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.service.maintenance",
+      path: "/agent/service/maintenance/{id}",
+      params: { id: opts.id },
+      query: { enable: opts.enable },
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+    if (typeof opts.enable !== "boolean") {
+      throw this.consul._err(errors.Validation("enable required"), req);
+    }
+    if (opts.reason) req.query.reason = opts.reason;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+}
+
+exports.AgentService = AgentService;

package/lib/agent.d.ts

@@ -0,0 +1,77 @@
+import { CommonOptions, Consul } from "./consul";
+import {
+  AgentCheck,
+  ListOptions as CheckListOptions,
+  ListResult as CheckListResult,
+} from "./agent/check";
+import {
+  AgentService,
+  ListOptions as ServiceListOptions,
+  ListResult as ServiceListResult,
+} from "./agent/service";
+
+interface MembersOptions extends CommonOptions {
+  wan?: boolean;
+  segment?: string;
+}
+
+type MembersResult = any[];
+
+interface ReloadOptions extends CommonOptions {}
+
+type ReloadResult = any;
+
+interface SelfOptions extends CommonOptions {}
+
+type SelfResult = any;
+
+interface MaintenanceOptions extends CommonOptions {
+  enable: boolean;
+  reason?: string;
+}
+
+type MaintenanceResult = any;
+
+interface JoinOptions extends CommonOptions {
+  address: string;
+  wan?: boolean;
+}
+
+type JoinResult = any;
+
+interface ForceLeaveOptions extends CommonOptions {
+  node: string;
+  prune?: boolean;
+  wan?: boolean;
+}
+
+type ForceLeaveResult = any;
+
+declare class Agent {
+  constructor(consul: Consul);
+
+  consul: Consul;
+  check: AgentCheck;
+  service: AgentService;
+
+  static Check: typeof AgentCheck;
+  static Service: typeof AgentService;
+
+  checks(options?: CheckListOptions): Promise<CheckListResult>;
+
+  services(options?: ServiceListOptions): Promise<ServiceListResult>;
+
+  members(options?: MembersOptions): Promise<MembersResult>;
+
+  reload(options?: ReloadOptions): Promise<ReloadResult>;
+
+  self(options?: SelfOptions): Promise<SelfResult>;
+
+  maintenance(options: MaintenanceOptions): Promise<MaintenanceResult>;
+  maintenance(enable: boolean): Promise<MaintenanceResult>;
+
+  join(options: JoinOptions): Promise<JoinResult>;
+  join(address: string): Promise<JoinResult>;
+
+  forceLeave(options: ForceLeaveOptions | string): Promise<ForceLeaveResult>;
+}

package/lib/agent.js

@@ -0,0 +1,162 @@
+const AgentCheck = require("./agent/check").AgentCheck;
+const AgentService = require("./agent/service").AgentService;
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Agent {
+  constructor(consul) {
+    this.consul = consul;
+    this.check = new Agent.Check(consul);
+    this.service = new Agent.Service(consul);
+  }
+
+  /**
+   * Returns the checks the local agent is managing
+   */
+  checks() {
+    return this.check.list.apply(this.check, arguments);
+  }
+
+  /**
+   * Returns the services local agent is managing
+   */
+  services() {
+    return this.service.list.apply(this.service, arguments);
+  }
+
+  /**
+   * Returns the members as seen by the local consul agent
+   */
+  async members(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.members",
+      path: "/agent/members",
+      query: {},
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Reload agent configuration
+   */
+  async reload(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.reload",
+      path: "/agent/reload",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Returns the local node configuration
+   */
+  async self(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.self",
+      path: "/agent/self",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Manages node maintenance mode
+   */
+  async maintenance(opts) {
+    if (typeof opts === "boolean") {
+      opts = { enable: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.maintenance",
+      path: "/agent/maintenance",
+      query: { enable: opts.enable },
+    };
+
+    if (typeof opts.enable !== "boolean") {
+      throw this.consul._err(errors.Validation("enable required"), req);
+    }
+    if (opts.reason) req.query.reason = opts.reason;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Trigger local agent to join a node
+   */
+  async join(opts) {
+    if (typeof opts === "string") {
+      opts = { address: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.join",
+      path: "/agent/join/{address}",
+      params: { address: opts.address },
+    };
+
+    if (!opts.address) {
+      throw this.consul._err(errors.Validation("address required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Force remove node
+   */
+  async forceLeave(opts) {
+    if (typeof opts === "string") {
+      opts = { node: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.forceLeave",
+      path: "/agent/force-leave/{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._put(req, utils.empty);
+  }
+}
+
+Agent.Check = AgentCheck;
+Agent.Service = AgentService;
+
+exports.Agent = Agent;

package/lib/catalog/connect.d.ts

@@ -0,0 +1,11 @@
+import { Consul } from "../consul";
+import { NodesOptions, NodesResult } from "./service";
+
+declare class CatalogConnect {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  nodes(options: NodesOptions): Promise<NodesResult>;
+  nodes(service: string): Promise<NodesResult>;
+}

package/lib/catalog/connect.js

@@ -0,0 +1,37 @@
+const errors = require("../errors");
+const utils = require("../utils");
+
+class CatalogConnect {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Lists the nodes in a given Connect-capable service
+   */
+  async nodes(opts) {
+    if (typeof opts === "string") {
+      opts = { service: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.connect.nodes",
+      path: "/catalog/connect/{service}",
+      params: { service: opts.service },
+      query: {},
+    };
+
+    if (!opts.service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+}
+
+exports.CatalogConnect = CatalogConnect;

package/lib/catalog/node.d.ts

@@ -0,0 +1,30 @@
+import { CommonOptions, Consul } from "../consul";
+
+interface ListOptions extends CommonOptions {
+  dc?: string;
+  near?: string;
+  filter?: string;
+}
+
+type ListResult = any[];
+
+interface ServicesOptions extends CommonOptions {
+  node: string;
+  dc?: string;
+  filter?: string;
+  ns?: string;
+}
+
+type ServicesResult = any;
+
+declare class CatalogNode {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  list(options?: ListOptions): Promise<ListResult>;
+  list(dc: string): Promise<ListResult>;
+
+  services(options: ServicesOptions): Promise<ServicesResult>;
+  services(node: string): Promise<ServicesResult>;
+}

package/lib/catalog/node.js

@@ -0,0 +1,57 @@
+const errors = require("../errors");
+const utils = require("../utils");
+
+class CatalogNode {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Lists nodes in a given DC
+   */
+  async list(opts) {
+    if (typeof opts === "string") {
+      opts = { dc: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.node.list",
+      path: "/catalog/nodes",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Lists the services provided by a node
+   */
+  async services(opts) {
+    if (typeof opts === "string") {
+      opts = { node: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.node.services",
+      path: "/catalog/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);
+  }
+}
+
+exports.CatalogNode = CatalogNode;

package/lib/catalog/service.d.ts

@@ -0,0 +1,32 @@
+import { CommonOptions, Consul } from "../consul";
+
+interface ListOptions extends CommonOptions {
+  dc?: string;
+  ns?: string;
+  filter?: string;
+}
+
+type ListResult = Record<string, string[]>;
+
+interface NodesOptions extends CommonOptions {
+  service: string;
+  dc?: string;
+  tag?: string;
+  near?: string;
+  filter?: string;
+  ns?: string;
+}
+
+type NodesResult = any[];
+
+declare class CatalogService {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  list(options?: ListOptions): Promise<ListResult>;
+  list(dc: string): Promise<ListResult>;
+
+  nodes(options: NodesOptions): Promise<NodesResult>;
+  nodes(service: string): Promise<NodesResult>;
+}

package/lib/catalog/service.js

@@ -0,0 +1,61 @@
+const errors = require("../errors");
+const utils = require("../utils");
+
+class CatalogService {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Lists services in a given DC
+   */
+
+  async list(opts) {
+    if (typeof opts === "string") {
+      opts = { dc: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.service.list",
+      path: "/catalog/services",
+      query: {},
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Lists the nodes in a given service
+   */
+  async nodes(opts) {
+    if (typeof opts === "string") {
+      opts = { service: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "catalog.service.nodes",
+      path: "/catalog/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;
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+}
+
+exports.CatalogService = CatalogService;

package/lib/catalog.d.ts

@@ -0,0 +1,118 @@
+import { CommonOptions, Consul } from "./consul";
+import { CatalogConnect } from "./catalog/connect";
+import {
+  CatalogNode,
+  ListOptions as NodeListOptions,
+  ListResult as NodeListResult,
+} from "./catalog/node";
+import {
+  CatalogService,
+  ListOptions as ServiceListOptions,
+  ListResult as ServiceListResult,
+} from "./catalog/service";
+
+interface DatacentersOptions extends CommonOptions {}
+
+type DatacentersResult = string[];
+
+type NodesOptions = NodeListOptions;
+
+type NodesResult = NodeListResult;
+
+interface RegisterService {
+  id?: string;
+  service: string;
+  address?: string;
+  port?: number;
+  tags?: string[];
+  meta?: Record<string, string>;
+}
+
+interface RegisterCheckHealthDefinitionBase {
+  intervalduration: string;
+  timeoutduration?: string;
+  deregistercriticalserviceafterduration?: string;
+}
+
+interface RegisterCheckHealthDefinitionHttp
+  extends RegisterCheckHealthDefinitionBase {
+  http: string;
+  tlsskipverify?: boolean;
+  tlsservername?: string;
+}
+
+interface RegisterCheckHealthDefinitionTcp
+  extends RegisterCheckHealthDefinitionBase {
+  tcp: string;
+}
+
+type RegisterCheckHealthDefinition =
+  | RegisterCheckHealthDefinitionHttp
+  | RegisterCheckHealthDefinitionTcp;
+
+interface RegisterCheck {
+  node?: string;
+  name?: string;
+  checkid?: string;
+  serviceid?: string;
+  notes?: string;
+  status?: "passing" | "warning" | "critical";
+  definition?: RegisterCheckHealthDefinition;
+}
+
+interface RegisterOptions extends CommonOptions {
+  id?: string;
+  node: string;
+  address: string;
+  datacenter?: string;
+  taggedaddresses?: Record<string, string>;
+  nodemeta?: Record<string, string>;
+  service?: RegisterService;
+  check?: RegisterCheck;
+  checks?: RegisterCheck[];
+  skipnodeupdate?: boolean;
+  namespace?: string;
+}
+
+type RegisterResult = any;
+
+interface DeregisterOptions extends CommonOptions {
+  node: string;
+  datacenter?: string;
+  checkid?: string;
+  serviceid?: string;
+  namespace?: string;
+}
+
+type DeregisterResult = any;
+
+type ServicesOptions = ServiceListOptions;
+
+type ServicesResult = ServiceListResult;
+
+declare class Catalog {
+  constructor(consul: Consul);
+
+  consul: Consul;
+  connect: CatalogConnect;
+  node: CatalogNode;
+  service: CatalogService;
+
+  static Connect: typeof CatalogConnect;
+  static Node: typeof CatalogNode;
+  static Service: typeof CatalogService;
+
+  datacenters(options?: DatacentersOptions): Promise<DatacentersResult>;
+
+  nodes(options: NodesOptions): Promise<NodesResult>;
+  nodes(service: string): Promise<NodesResult>;
+
+  register(options: RegisterOptions): Promise<RegisterResult>;
+  register(node: string): Promise<RegisterResult>;
+
+  deregister(options: DeregisterOptions): Promise<DeregisterResult>;
+  deregister(node: string): Promise<DeregisterResult>;
+
+  services(options?: ServicesOptions): Promise<ServicesResult>;
+  services(dc: string): Promise<ServicesResult>;
+}