@brimble/consul 2.0.1

package/lib/query.js

@@ -0,0 +1,244 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Query {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Lists all queries
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.list",
+      path: "/query",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Create a new query
+   */
+  async create(opts) {
+    if (typeof opts === "string") {
+      opts = { service: { service: opts } };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.create",
+      path: "/query",
+      query: {},
+      type: "json",
+    };
+
+    this._params(req, opts);
+
+    if (!req.body.Service || !req.body.Service.Service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    utils.options(req, opts, { near: true });
+
+    return await this.consul._post(req, utils.body);
+  }
+
+  /**
+   * Gets a given query
+   */
+  async get(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.get",
+      path: "/query/{query}",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.bodyItem);
+  }
+
+  /**
+   * Update existing query
+   */
+  async update(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.update",
+      path: "/query/{query}",
+      params: { query: opts.query },
+      query: {},
+      type: "json",
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    this._params(req, opts);
+
+    if (!req.body.Service || !req.body.Service.Service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    utils.options(req, opts, { near: true });
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Destroys a given query
+   */
+  async destroy(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.destroy",
+      path: "/query/{query}",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._delete(req, utils.empty);
+  }
+
+  /**
+   * Executes a given query
+   */
+  async execute(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.execute",
+      path: "/query/{query}/execute",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Explain a given query
+   */
+  async explain(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.explain",
+      path: "/query/{query}/explain",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.bodyItem);
+  }
+
+  /**
+   * Generate body for query create and update
+   */
+  _params(req, opts) {
+    const body = req.body || {};
+
+    if (opts.name) body.Name = opts.name;
+    if (opts.session) body.Session = opts.session;
+    if (opts.token) {
+      body.Token = opts.token;
+      delete opts.token;
+    }
+    if (opts.near) body.Near = opts.near;
+    if (opts.template) {
+      const template = utils.normalizeKeys(opts.template);
+      if (template.type || template.regexp) {
+        body.Template = {};
+        if (template.type) body.Template.Type = template.type;
+        if (template.regexp) body.Template.Regexp = template.regexp;
+      }
+    }
+    if (opts.service) {
+      const service = utils.normalizeKeys(opts.service);
+      body.Service = {};
+      if (service.service) body.Service.Service = service.service;
+      if (service.failover) {
+        const failover = utils.normalizeKeys(service.failover);
+        if (typeof failover.nearestn === "number" || failover.datacenters) {
+          body.Service.Failover = {};
+          if (typeof failover.nearestn === "number") {
+            body.Service.Failover.NearestN = failover.nearestn;
+          }
+          if (failover.datacenters) {
+            body.Service.Failover.Datacenters = failover.datacenters;
+          }
+        }
+      }
+      if (typeof service.onlypassing === "boolean") {
+        body.Service.OnlyPassing = service.onlypassing;
+      }
+      if (service.tags) body.Service.Tags = service.tags;
+    }
+    if (opts.dns) {
+      const dns = utils.normalizeKeys(opts.dns);
+      if (dns.ttl) body.DNS = { TTL: dns.ttl };
+    }
+
+    req.body = body;
+  }
+}
+
+exports.Query = Query;

package/lib/session.d.ts

@@ -0,0 +1,92 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface CreateOptions extends CommonOptions {
+  dc?: string;
+  lockdelay?: string;
+  node?: string;
+  name?: string;
+  checks?: string[];
+  nodechecks?: string[];
+  servicechecks?: { id: string; namespace?: string }[];
+  behavior?: "release" | "delete";
+  ttl?: string;
+}
+
+interface CreateResult {
+  ID: string;
+}
+
+interface DestroyOptions extends CommonOptions {
+  id: string;
+  dc?: string;
+  ns?: string;
+}
+
+type DestroyResult = boolean;
+
+interface InfoOptions extends CommonOptions {
+  id: string;
+  dc?: string;
+}
+
+interface InfoResult {
+  ID: string;
+  Name: string;
+  Node: string;
+  LockDelay: number;
+  Behavior: "release" | "delete";
+  TTL: string;
+  NodeChecks: string[] | null;
+  ServiceChecks: string[] | null;
+  CreateIndex: number;
+  ModifyIndex: number;
+}
+
+type GetOptions = InfoOptions;
+
+type GetResult = InfoResult;
+
+interface NodeOptions extends CommonOptions {
+  node: string;
+  dc?: string;
+}
+
+type NodeResult = InfoResult[];
+
+interface ListOptions extends CommonOptions {
+  dc?: string;
+}
+
+type ListResult = InfoResult[];
+
+interface RenewOptions extends CommonOptions {
+  id: string;
+  dc?: string;
+}
+
+type RenewResult = InfoResult[];
+
+declare class Session {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  create(options?: CreateOptions): Promise<CreateResult>;
+
+  destroy(options: DestroyOptions): Promise<DestroyResult>;
+  destroy(id: string): Promise<DestroyResult>;
+
+  info(options: InfoOptions): Promise<InfoResult>;
+  info(id: string): Promise<InfoResult>;
+
+  get(options: GetOptions): Promise<GetResult>;
+  get(id: string): Promise<GetResult>;
+
+  node(options: NodeOptions): Promise<NodeResult>;
+  node(node: string): Promise<NodeResult>;
+
+  list(options?: ListOptions): Promise<ListResult>;
+
+  renew(options: RenewOptions): Promise<RenewResult>;
+  renew(id: string): Promise<RenewResult>;
+}

package/lib/session.js

@@ -0,0 +1,164 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Session {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Creates a new session
+   */
+  async create(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "session.create",
+      path: "/session/create",
+      query: {},
+      type: "json",
+      body: {},
+    };
+
+    if (opts.lockdelay) req.body.LockDelay = opts.lockdelay;
+    if (opts.name) req.body.Name = opts.name;
+    if (opts.node) req.body.Node = opts.node;
+    if (opts.checks) req.body.Checks = opts.checks;
+    if (opts.behavior) req.body.Behavior = opts.behavior;
+    if (opts.ttl) req.body.TTL = opts.ttl;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.body);
+  }
+
+  /**
+   * Destroys a given session
+   */
+  async destroy(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "session.destroy",
+      path: "/session/destroy/{id}",
+      params: { id: opts.id },
+      query: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Queries a given session
+   */
+  async info(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "session.info",
+      path: "/session/info/{id}",
+      params: { id: opts.id },
+      query: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.bodyItem);
+  }
+
+  get(opts) {
+    return this.info(opts);
+  }
+
+  /**
+   * Lists sessions belonging to 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: "session.node",
+      path: "/session/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);
+  }
+
+  /**
+   * Lists all the active sessions
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "session.list",
+      path: "/session/list",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Renews a TTL-based session
+   */
+  async renew(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "session.renew",
+      path: "/session/renew/{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.body);
+  }
+}
+
+exports.Session = Session;

package/lib/status.d.ts

@@ -0,0 +1,19 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface LeaderOptions extends CommonOptions {}
+
+type LeaderResult = string;
+
+interface PeersOptions extends CommonOptions {}
+
+type PeersResult = string[];
+
+declare class Status {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  leader(options?: LeaderOptions): Promise<LeaderResult>;
+
+  peers(options?: PeersOptions): Promise<PeersResult>;
+}

package/lib/status.js

@@ -0,0 +1,43 @@
+const utils = require("./utils");
+
+class Status {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Returns the current Raft leader.
+   */
+  async leader(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "status.leader",
+      path: "/status/leader",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Returns the current Raft peer set
+   */
+  async peers(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "status.peers",
+      path: "/status/peers",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+}
+
+exports.Status = Status;

package/lib/transaction.d.ts

@@ -0,0 +1,50 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface KVOption {
+  verb: string;
+  key: string;
+  value?: string;
+  flags?: number;
+  index?: number;
+  session?: string;
+  namespace?: string;
+}
+
+interface NodeOption {
+  verb: string;
+  node: any;
+}
+
+interface ServiceOption {
+  verb: string;
+  node: string;
+  service: any;
+}
+
+interface CheckOption {
+  verb: string;
+  check: any;
+}
+
+type Operation = KVOption | NodeOption | ServiceOption | CheckOption;
+
+interface CreateOptions extends CommonOptions {
+  operations: Operation[];
+}
+
+interface CreateResult {
+  Results?: Record<"KV" | "Node" | "Service" | "Check", any>[];
+  Errors?: any[];
+}
+
+declare class Transaction {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  create(options: CreateOptions): Promise<CreateResult>;
+  create(
+    operations: Operation[],
+    options: CreateOptions,
+  ): Promise<CreateResult>;
+}

package/lib/transaction.js

@@ -0,0 +1,58 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Transaction {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Create
+   */
+  async create(operations) {
+    let opts;
+    switch (arguments.length) {
+      case 2:
+        // create(operations, opts)
+        opts = utils.clone(arguments[1]);
+        opts.operations = operations;
+        break;
+      case 1:
+        // create(operations)
+        opts = { operations };
+        break;
+      default:
+        throw this.consul._err(
+          errors.Validation(
+            "a list of operations are required as first arguments",
+          ),
+          { name: "Transaction.create" },
+        );
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "Transaction.create",
+      path: "/txn",
+      params: {},
+      query: {},
+      type: "json",
+      body: opts.operations,
+    };
+
+    if (!(Array.isArray(opts.operations) && opts.operations.length > 0)) {
+      throw this.consul._err(
+        errors.Validation("operations must be an array with at least one item"),
+        req,
+      );
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.body);
+  }
+}
+
+exports.Transaction = Transaction;