@brimble/consul 0.0.1

package/lib/acl/legacy.d.ts

@@ -0,0 +1,75 @@
+import { Consul } from "../consul";
+
+interface CreateOptions {
+  name?: string;
+  type?: "client" | "management";
+  rules?: string;
+}
+
+type CreateResult = any;
+
+interface UpdateOptions {
+  id: string;
+  name?: string;
+  type?: "client" | "management";
+  rules?: string;
+}
+
+type UpdateResult = any;
+
+interface DestroyOptions {
+  id: string;
+}
+
+type DestroyResult = any;
+
+interface InfoOptions {
+  id: string;
+}
+
+interface InfoResult {
+  CreateIndex: number;
+  ModifyIndex: number;
+  ID: string;
+  Name: string;
+  Type: "client" | "management";
+  Rules: string;
+}
+
+type GetOptions = InfoOptions;
+
+type GetResult = InfoResult;
+
+interface CloneOptions {
+  id: string;
+}
+
+type CloneResult = any;
+
+interface ListOptions {}
+
+type ListResult = GetResult[];
+
+declare class AclLegacy {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  create(options?: CreateOptions): Promise<CreateResult>;
+
+  update(options: UpdateOptions): Promise<UpdateResult>;
+
+  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>;
+
+  clone(options: CloneOptions): Promise<CloneResult>;
+  clone(id: string): Promise<CloneResult>;
+
+  list(options?: ListOptions): Promise<ListResult>;
+}

package/lib/acl/legacy.js

@@ -0,0 +1,167 @@
+const errors = require("../errors");
+const utils = require("../utils");
+
+class AclLegacy {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Creates a new token with policy
+   */
+  async create(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.legacy.create",
+      path: "/acl/create",
+      query: {},
+      type: "json",
+      body: {},
+    };
+
+    if (opts.name) req.body.Name = opts.name;
+    if (opts.type) req.body.Type = opts.type;
+    if (opts.rules) req.body.Rules = opts.rules;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.body);
+  }
+
+  /**
+   * Update the policy of a token
+   */
+  async update(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.legacy.update",
+      path: "/acl/update",
+      query: {},
+      type: "json",
+      body: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    req.body.ID = opts.id;
+
+    if (opts.name) req.body.Name = opts.name;
+    if (opts.type) req.body.Type = opts.type;
+    if (opts.rules) req.body.Rules = opts.rules;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Destroys a given token
+   */
+  async destroy(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.legacy.destroy",
+      path: "/acl/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 the policy of a given token
+   */
+  async info(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.legacy.info",
+      path: "/acl/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(...args) {
+    return this.info(...args);
+  }
+
+  /**
+   * Creates a new token by cloning an existing token
+   */
+  async clone(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.legacy.clone",
+      path: "/acl/clone/{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.body);
+  }
+
+  /**
+   * Lists all the active tokens
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.legacy.list",
+      path: "/acl/list",
+      query: {},
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+}
+
+exports.AclLegacy = AclLegacy;

package/lib/acl.d.ts

@@ -0,0 +1,37 @@
+import { AclLegacy } from "./acl/legacy";
+import { CommonOptions, Consul } from "./consul";
+
+interface BootstrapOptions extends CommonOptions {
+  bootstrapsecret?: string;
+}
+
+type BootstrapResult = any;
+
+interface ReplicationOptions extends CommonOptions {
+  dc?: string;
+}
+
+interface ReplicationResult {
+  Enabled: boolean;
+  Running: boolean;
+  SourceDatacenter: string;
+  ReplicatedType: "policies" | "tokens";
+  ReplicatedIndex: number;
+  ReplicatedTokenIndex: number;
+  LastSuccess: string;
+  LastError: string;
+  LastErrorMessage: string;
+}
+
+declare class Acl {
+  constructor(consul: Consul);
+
+  consul: Consul;
+  legacy: AclLegacy;
+
+  static Legacy: typeof AclLegacy;
+
+  bootstrap(options?: BootstrapOptions): Promise<BootstrapResult>;
+
+  replication(options?: ReplicationOptions): Promise<ReplicationResult>;
+}

package/lib/acl.js

@@ -0,0 +1,49 @@
+const AclLegacy = require("./acl/legacy").AclLegacy;
+const utils = require("./utils");
+
+class Acl {
+  constructor(consul) {
+    this.consul = consul;
+    this.legacy = new Acl.Legacy(consul);
+  }
+
+  /**
+   * Creates one-time management token if not configured
+   */
+  async bootstrap(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.bootstrap",
+      path: "/acl/bootstrap",
+      type: "json",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.body);
+  }
+
+  /**
+   * Check ACL replication
+   */
+  async replication(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "acl.replication",
+      path: "/acl/replication",
+      query: {},
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+}
+
+Acl.Legacy = AclLegacy;
+
+exports.Acl = Acl;

package/lib/agent/check.d.ts

@@ -0,0 +1,113 @@
+import { CommonOptions, Consul } from "../consul";
+
+interface ListOptions extends CommonOptions {
+  filter?: string;
+  ns?: string;
+}
+
+interface Check {
+  Node: string;
+  CheckID: string;
+  Name: string;
+  Status: "passing" | "warning" | "critical";
+  Notes: string;
+  Output: string;
+  ServiceID: string;
+  ServiceName: string;
+  ServiceTags: string[];
+  Interval: string;
+  Timeout: string;
+  Type: string;
+  ExposedPort: number;
+  Definition: any;
+  Namespace: string;
+  CreateIndex: number;
+  ModifyIndex: number;
+}
+
+type ListResult = Record<string, Check>;
+
+export interface CheckOptions {
+  name: string;
+  checkid?: string;
+  serviceid?: string;
+  http?: string;
+  body?: string;
+  header?: Record<string, string>;
+  disableredirects?: boolean;
+  h2ping?: string;
+  h2pingusetls?: boolean;
+  tlsskipverify?: boolean;
+  tcp?: string;
+  udp?: string;
+  args?: string[];
+  script?: string;
+  dockercontainerid?: string;
+  grpc?: string;
+  grpcusetls?: boolean;
+  shell?: string;
+  timeout: string;
+  interval?: string;
+  ttl?: string;
+  aliasnode?: string;
+  aliasservice?: string;
+  notes?: string;
+  status?: string;
+  deregistercriticalserviceafter?: string;
+  failuresbeforewarning?: number;
+  successbeforepassing?: number;
+  failuresbeforecritical?: number;
+}
+
+interface RegisterOptions extends CheckOptions, CommonOptions {}
+
+type RegisterResult = any;
+
+interface DeregisterOptions extends CommonOptions {
+  id: string;
+}
+
+type DeregisterResult = any;
+
+interface PassOptions extends CommonOptions {
+  id: string;
+  note?: string;
+}
+
+type PassResult = any;
+
+interface WarnOptions extends CommonOptions {
+  id: string;
+  note?: string;
+}
+
+type WarnResult = any;
+
+interface FailOptions extends CommonOptions {
+  id: string;
+  note?: string;
+}
+
+type FailResult = any;
+
+declare class AgentCheck {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  list(options?: ListOptions): Promise<ListResult>;
+
+  register(options: RegisterOptions): Promise<RegisterResult>;
+
+  deregister(options: DeregisterOptions): Promise<DeregisterResult>;
+  deregister(id: string): Promise<DeregisterResult>;
+
+  pass(options: PassOptions): Promise<PassResult>;
+  pass(id: string): Promise<PassResult>;
+
+  warn(options: WarnOptions): Promise<WarnResult>;
+  warn(id: string): Promise<WarnResult>;
+
+  fail(options: FailOptions): Promise<FailResult>;
+  fail(id: string): Promise<FailResult>;
+}

package/lib/agent/check.js

@@ -0,0 +1,164 @@
+const errors = require("../errors");
+const utils = require("../utils");
+
+class AgentCheck {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Returns the checks the local agent is managing
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.check.list",
+      path: "/agent/checks",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Registers a new local check
+   */
+  async register(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.check.register",
+      path: "/agent/check/register",
+      type: "json",
+    };
+
+    try {
+      req.body = utils.createCheck(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 check
+   */
+  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.check.deregister",
+      path: "/agent/check/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);
+  }
+
+  /**
+   * Mark a local test as passing
+   */
+  async pass(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.check.pass",
+      path: "/agent/check/pass/{id}",
+      params: { id: opts.id },
+      query: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    if (opts.note) req.query.note = opts.note;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Mark a local test as warning
+   */
+  async warn(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.check.warn",
+      path: "/agent/check/warn/{id}",
+      params: { id: opts.id },
+      query: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    if (opts.note) req.query.note = opts.note;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Mark a local test as critical
+   */
+  async fail(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "agent.check.fail",
+      path: "/agent/check/fail/{id}",
+      params: { id: opts.id },
+      query: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+
+    if (opts.note) req.query.note = opts.note;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+}
+
+exports.AgentCheck = AgentCheck;

package/lib/agent/service.d.ts

@@ -0,0 +1,63 @@
+import { CommonOptions, Consul } from "../consul";
+import { CheckOptions } from "./check";
+
+interface ListOptions extends CommonOptions {
+  filter?: string;
+}
+
+type ListResult = Record<string, any>;
+
+interface RegisterConnect {
+  native?: boolean;
+  proxy?: any;
+  sidecarservice: Record<string, any>;
+}
+
+interface RegisterOptions extends CommonOptions {
+  name: string;
+  id?: string;
+  tags?: string[];
+  address?: string;
+  taggedaddresses?: Record<string, any>;
+  meta?: Record<string, string>;
+  namespace?: string;
+  port?: number;
+  kind?: string;
+  proxy?: any;
+  connect?: RegisterConnect;
+  check?: CheckOptions;
+  checks?: CheckOptions[];
+}
+
+type RegisterResult = any;
+
+interface DeregisterOptions extends CommonOptions {
+  id: string;
+}
+
+type DeregisterResult = any;
+
+interface MaintenanceOptions extends CommonOptions {
+  id: string;
+  enable: boolean;
+  reason?: string;
+  ns?: string;
+}
+
+type MaintenanceResult = any;
+
+declare class AgentService {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  list(options?: ListOptions): Promise<ListResult>;
+
+  register(options: RegisterOptions): Promise<RegisterResult>;
+  register(name: string): Promise<RegisterResult>;
+
+  deregister(options: DeregisterOptions): Promise<DeregisterResult>;
+  deregister(id: string): Promise<DeregisterResult>;
+
+  maintenance(options: MaintenanceOptions): Promise<MaintenanceResult>;
+}