@brimble/consul 0.0.1

package/lib/index.js

@@ -0,0 +1,3 @@
+const { Consul } = require("./consul");
+
+module.exports = Consul;

package/lib/intention.d.ts

@@ -0,0 +1,73 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface ListOptions extends CommonOptions {}
+
+interface IntentionResult {
+  ID: string;
+  SourceName: string;
+  DestinationName: string;
+  SourceType?: string;
+  Action: "allow" | "deny";
+  Description?: string;
+  Meta?: Record<string, string>;
+  Precedence?: number;
+  Permissions?: any[];
+  CreateIndex?: number;
+  ModifyIndex?: number;
+}
+
+type ListResult = IntentionResult[];
+
+interface CreateOptions extends CommonOptions {
+  sourcename: string;
+  destinationname: string;
+  action: "allow" | "deny";
+  description?: string;
+  sourcetype?: string;
+  meta?: Record<string, string>;
+  precedence?: number;
+  permissions?: any[];
+}
+
+interface CreateResult {
+  ID: string;
+}
+
+interface GetOptions extends CommonOptions {
+  id: string;
+}
+
+type GetResult = IntentionResult;
+
+interface UpdateOptions extends CreateOptions {
+  id: string;
+}
+
+type UpdateResult = boolean;
+
+interface DestroyOptions extends CommonOptions {
+  id: string;
+}
+
+type DestroyResult = boolean;
+
+declare class Intention {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  list(options?: ListOptions): Promise<ListResult>;
+
+  create(options: CreateOptions): Promise<CreateResult>;
+
+  get(options: GetOptions): Promise<GetResult>;
+  get(id: string): Promise<GetResult>;
+
+  update(options: UpdateOptions): Promise<UpdateResult>;
+
+  destroy(options: DestroyOptions): Promise<DestroyResult>;
+  destroy(id: string): Promise<DestroyResult>;
+
+  delete(options: DestroyOptions): Promise<DestroyResult>;
+  delete(id: string): Promise<DestroyResult>;
+}

package/lib/intention.js

@@ -0,0 +1,180 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Intention {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Lists all intentions
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "intention.list",
+      path: "/connect/intentions",
+      query: {},
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Creates a new intention
+   */
+  async create(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "intention.create",
+      path: "/connect/intentions",
+      query: {},
+      type: "json",
+      body: {},
+    };
+
+    if (!opts.sourcename) {
+      throw this.consul._err(errors.Validation("sourcename required"), req);
+    }
+    if (!opts.destinationname) {
+      throw this.consul._err(
+        errors.Validation("destinationname required"),
+        req,
+      );
+    }
+    if (!opts.action) {
+      throw this.consul._err(errors.Validation("action required"), req);
+    }
+
+    req.body.SourceName = opts.sourcename;
+    req.body.DestinationName = opts.destinationname;
+    req.body.Action = opts.action;
+
+    if (opts.description) req.body.Description = opts.description;
+    if (opts.sourcetype) req.body.SourceType = opts.sourcetype;
+    if (opts.meta) req.body.Meta = opts.meta;
+    if (typeof opts.precedence === "number") {
+      req.body.Precedence = opts.precedence;
+    }
+    if (opts.permissions) req.body.Permissions = opts.permissions;
+
+    utils.options(req, opts);
+
+    return await this.consul._post(req, utils.body);
+  }
+
+  /**
+   * Gets a given intention
+   */
+  async get(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "intention.get",
+      path: "/connect/intentions/{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);
+  }
+
+  /**
+   * Updates an existing intention
+   */
+  async update(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "intention.update",
+      path: "/connect/intentions/{id}",
+      params: { id: opts.id },
+      query: {},
+      type: "json",
+      body: {},
+    };
+
+    if (!opts.id) {
+      throw this.consul._err(errors.Validation("id required"), req);
+    }
+    if (!opts.sourcename) {
+      throw this.consul._err(errors.Validation("sourcename required"), req);
+    }
+    if (!opts.destinationname) {
+      throw this.consul._err(
+        errors.Validation("destinationname required"),
+        req,
+      );
+    }
+    if (!opts.action) {
+      throw this.consul._err(errors.Validation("action required"), req);
+    }
+
+    req.body.SourceName = opts.sourcename;
+    req.body.DestinationName = opts.destinationname;
+    req.body.Action = opts.action;
+
+    if (opts.description) req.body.Description = opts.description;
+    if (opts.sourcetype) req.body.SourceType = opts.sourcetype;
+    if (opts.meta) req.body.Meta = opts.meta;
+    if (typeof opts.precedence === "number") {
+      req.body.Precedence = opts.precedence;
+    }
+    if (opts.permissions) req.body.Permissions = opts.permissions;
+
+    utils.options(req, opts);
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Deletes a given intention
+   */
+  async destroy(opts) {
+    if (typeof opts === "string") {
+      opts = { id: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "intention.destroy",
+      path: "/connect/intentions/{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._delete(req, utils.empty);
+  }
+
+  delete() {
+    return this.destroy.apply(this, arguments);
+  }
+}
+
+exports.Intention = Intention;

package/lib/kv.d.ts

@@ -0,0 +1,80 @@
+import { Consul } from "./consul";
+
+interface GetOptions {
+  key?: string;
+  dc?: string;
+  raw?: boolean;
+  keys?: boolean;
+  separator?: string;
+  ns?: string;
+}
+
+interface GetOptionsRecurse extends GetOptions {
+  recurse: boolean;
+}
+
+interface GetItem {
+  CreateIndex: number;
+  ModifyIndex: number;
+  LockIndex: number;
+  Key: string;
+  Flags: number;
+  Value: string | null;
+}
+
+type GetResult = GetItem | null;
+
+type GetResultRecurse = GetItem[] | GetItem | null;
+
+interface KeysOptions extends GetOptions {
+  recurse?: boolean;
+}
+
+type KeysResult = string[];
+
+interface SetOptions {
+  key?: string;
+  value: string | Buffer;
+  dc?: string;
+  flags?: number;
+  cas?: number;
+  acquire?: string;
+  release?: string;
+  ns?: string;
+}
+
+type SetResult = boolean;
+
+interface DelOptions {
+  key?: string;
+  dc?: string;
+  recurse?: boolean;
+  cas?: number;
+  ns?: string;
+}
+
+type DelResult = boolean;
+
+declare class Kv {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  get(options?: GetOptions): Promise<GetResult>;
+  get(key: string): Promise<GetResult>;
+  get(options?: GetOptionsRecurse): Promise<GetResultRecurse>;
+
+  keys(options?: KeysOptions): Promise<KeysResult>;
+  keys(key: string): Promise<KeysResult>;
+
+  set(options: SetOptions): Promise<SetResult>;
+  set(key: string, value: string | Buffer): Promise<SetResult>;
+  set(
+    key: string,
+    value: string | Buffer,
+    options: SetOptions,
+  ): Promise<SetResult>;
+
+  del(options: DelOptions): Promise<DelResult>;
+  del(key: string): Promise<DelResult>;
+}

package/lib/kv.js

@@ -0,0 +1,180 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Kv {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Get
+   */
+  async get(opts) {
+    if (typeof opts === "string") {
+      opts = { key: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "kv.get",
+      path: "/kv/{key}",
+      params: { key: opts.key || "" },
+      query: {},
+    };
+
+    if (opts.recurse) req.query.recurse = "true";
+    if (opts.raw) {
+      req.query.raw = "true";
+      req.buffer = true;
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, function (request, next) {
+      const res = request.res;
+
+      if (res && res.statusCode === 404) {
+        return next(false, undefined, utils.responseResult(request));
+      }
+      if (request.err) {
+        utils.applyErrorResponse(request);
+        return next(request.err);
+      }
+      if (opts.raw) {
+        return next(false, undefined, utils.responseResult(request, res.body));
+      }
+
+      if (res.body && Array.isArray(res.body) && res.body.length) {
+        res.body.forEach((item) => {
+          if (item.hasOwnProperty("Value")) {
+            item.Value = utils.decode(item.Value, opts);
+          }
+        });
+      } else {
+        return next(false, undefined, utils.responseResult(request));
+      }
+
+      if (!opts.recurse) {
+        return next(
+          false,
+          undefined,
+          utils.responseResult(request, res.body[0]),
+        );
+      }
+
+      next(false, undefined, utils.responseResult(request, res.body));
+    });
+  }
+
+  /**
+   * Keys
+   */
+  async keys(opts) {
+    if (typeof opts === "string") {
+      opts = { key: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "kv.keys",
+      path: "/kv/{key}",
+      params: { key: opts.key || "" },
+      query: { keys: true },
+    };
+
+    if (opts.separator) req.query.separator = opts.separator;
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Set
+   */
+  async set(opts) {
+    let options;
+    switch (arguments.length) {
+      case 3:
+        // set(key, value, opts)
+        options = arguments[2];
+        options.key = arguments[0];
+        options.value = arguments[1];
+        break;
+      case 2:
+        // set(key, value)
+        options = {
+          key: arguments[0],
+          value: arguments[1],
+        };
+        break;
+      default:
+        options = opts;
+    }
+
+    options = utils.normalizeKeys(options);
+    options = utils.defaults(options, this.consul._defaults);
+
+    const req = {
+      name: "kv.set",
+      path: "/kv/{key}",
+      params: { key: options.key },
+      query: {},
+      type: "text",
+      body: options.value || "",
+    };
+
+    if (!options.key) {
+      throw this.consul._err(errors.Validation("key required"), req);
+    }
+    if (!options.hasOwnProperty("value")) {
+      throw this.consul._err(errors.Validation("value required"), req);
+    }
+
+    if (options.hasOwnProperty("cas")) req.query.cas = options.cas;
+    if (options.hasOwnProperty("flags")) req.query.flags = options.flags;
+    if (options.hasOwnProperty("acquire")) req.query.acquire = options.acquire;
+    if (options.hasOwnProperty("release")) req.query.release = options.release;
+
+    utils.options(req, options);
+
+    return await this.consul._put(req, utils.body);
+  }
+
+  /**
+   * Delete
+   */
+  async del(opts) {
+    if (typeof opts === "string") {
+      opts = { key: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "kv.del",
+      path: "/kv/{key}",
+      params: { key: opts.key || "" },
+      query: {},
+    };
+
+    if (opts.recurse) req.query.recurse = "true";
+
+    if (opts.hasOwnProperty("cas")) req.query.cas = opts.cas;
+
+    utils.options(req, opts);
+
+    return await this.consul._delete(req, utils.body);
+  }
+
+  delete() {
+    return this.del.apply(this, arguments);
+  }
+}
+
+exports.Kv = Kv;

package/lib/query.d.ts

@@ -0,0 +1,84 @@
+import { CommonOptions, Consul } from "./consul";
+
+interface ListOptions extends CommonOptions {}
+
+type ListResult = any[];
+
+interface CreateServiceOptions {
+  service: string;
+  namespace?: string;
+  failover?: {
+    nearestn?: number;
+    datacenters?: string[];
+    targets?: { peer?: string; datacenter?: string }[];
+  };
+  ignorecheckids?: string[];
+  onlypassing?: boolean;
+  near?: string;
+}
+
+interface CreateDnsOptions {
+  ttl?: string;
+}
+
+interface CreateOptions extends CommonOptions {
+  name?: string;
+  session?: string;
+  token?: string;
+  service: CreateServiceOptions;
+  tags?: string[];
+  nodemeta?: Record<string, string>;
+  servicemeta?: Record<string, string>;
+  connect?: boolean;
+  dns?: CreateDnsOptions;
+}
+
+interface CreateResult {
+  ID: string;
+}
+
+interface GetOptions extends CommonOptions {
+  query: string;
+}
+
+type GetResult = any;
+
+interface UpdateOptions extends CreateOptions {
+  query: string;
+}
+
+type UpdateResult = any;
+
+interface ExecuteOptions extends CommonOptions {
+  query: string;
+}
+
+type ExecuteResult = any;
+
+interface ExplainOptions extends CommonOptions {
+  query: string;
+}
+
+type ExplainResult = any;
+
+declare class Query {
+  constructor(consul: Consul);
+
+  consul: Consul;
+
+  list(options?: ListOptions): Promise<ListResult>;
+
+  create(options: CreateOptions): Promise<CreateResult>;
+  create(service: string): Promise<CreateResult>;
+
+  get(options: GetOptions): Promise<GetResult>;
+  get(query: string): Promise<GetResult>;
+
+  update(options: UpdateOptions): Promise<UpdateResult>;
+
+  execute(options: ExecuteOptions): Promise<ExecuteResult>;
+  execute(query: string): Promise<ExecuteResult>;
+
+  explain(options: ExplainOptions): Promise<ExplainResult>;
+  explain(query: string): Promise<ExplainResult>;
+}