@readme/httpsnippet 3.1.3 → 4.0.0

package/src/targets/targets.ts

@@ -0,0 +1,203 @@
+import type { Merge } from 'type-fest';
+
+import type { CodeBuilderOptions } from '../helpers/code-builder';
+import type { Request } from '..';
+import { c } from './c/target';
+import { clojure } from './clojure/target';
+import { csharp } from './csharp/target';
+import { go } from './go/target';
+import { http } from './http/target';
+import { java } from './java/target';
+import { javascript } from './javascript/target';
+import { kotlin } from './kotlin/target';
+import { node } from './node/target';
+import { objc } from './objc/target';
+import { ocaml } from './ocaml/target';
+import { php } from './php/target';
+import { powershell } from './powershell/target';
+import { python } from './python/target';
+import { r } from './r/target';
+import { ruby } from './ruby/target';
+import { shell } from './shell/target';
+import { swift } from './swift/target';
+
+export type TargetId = keyof typeof targets;
+
+export type ClientId = string;
+
+export interface ClientInfo {
+  key: ClientId;
+  title: string;
+  link: string;
+  description: string;
+}
+
+export type Converter<T extends Record<string, any>> = (
+  request: Request,
+  options?: Merge<CodeBuilderOptions, T>
+) => string;
+
+export interface Client<T extends Record<string, any> = Record<string, any>> {
+  info: ClientInfo;
+  convert: Converter<T>;
+}
+
+export type Extension = `.${string}` | null;
+
+export interface TargetInfo {
+  key: TargetId;
+  title: string;
+  extname: Extension;
+  default: string;
+  cli?: string;
+}
+
+export interface Target {
+  info: TargetInfo;
+  clientsById: Record<ClientId, Client>;
+}
+
+export const targets = {
+  c,
+  clojure,
+  csharp,
+  go,
+  http,
+  java,
+  javascript,
+  kotlin,
+  node,
+  objc,
+  ocaml,
+  php,
+  powershell,
+  python,
+  r,
+  ruby,
+  shell,
+  swift,
+};
+
+export const isTarget = (target: Target): target is Target => {
+  if (typeof target !== 'object' || target === null || Array.isArray(target)) {
+    const got = target === null ? 'null' : Array.isArray(target) ? 'array' : typeof target;
+    throw new Error(`you tried to add a target which is not an object, got type: "${got}"`);
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target, 'info')) {
+    throw new Error('targets must contain an `info` object');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target.info, 'key')) {
+    throw new Error('targets must have an `info` object with the property `key`');
+  }
+
+  if (!target.info.key) {
+    throw new Error('target key must be a unique string');
+  }
+
+  if (Object.prototype.hasOwnProperty.call(targets, target.info.key)) {
+    throw new Error(`a target already exists with this key, \`${target.info.key}\``);
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target.info, 'title')) {
+    throw new Error('targets must have an `info` object with the property `title`');
+  }
+
+  if (!target.info.title) {
+    throw new Error('target title must be a non-zero-length string');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target.info, 'extname')) {
+    throw new Error('targets must have an `info` object with the property `extname`');
+  }
+
+  if (
+    !Object.prototype.hasOwnProperty.call(target, 'clientsById') ||
+    !target.clientsById ||
+    Object.keys(target.clientsById).length === 0
+  ) {
+    throw new Error(
+      `No clients provided in target ${target.info.key}.  You must provide the property \`clientsById\` containg your clients.`
+    );
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target.info, 'default')) {
+    throw new Error('targets must have an `info` object with the property `default`');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target.clientsById, target.info.default)) {
+    throw new Error(
+      `target ${target.info.key} is configured with a default client ${
+        target.info.default
+      }, but no such client was found in the property \`clientsById\` (found ${JSON.stringify(
+        Object.keys(target.clientsById)
+      )})`
+    );
+  }
+
+  Object.values(target.clientsById).forEach(isClient);
+
+  return true;
+};
+
+export const addTarget = (target: Target) => {
+  if (!isTarget(target)) {
+    return;
+  }
+  targets[target.info.key] = target;
+};
+
+export const isClient = (client: Client): client is Client => {
+  if (!client) {
+    throw new Error('clients must be objects');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(client, 'info')) {
+    throw new Error('targets client must contain an `info` object');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(client.info, 'key')) {
+    throw new Error('targets client must have an `info` object with property `key`');
+  }
+
+  if (!client.info.key) {
+    throw new Error('client.info.key must contain an identifier unique to this target');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(client.info, 'title')) {
+    throw new Error('targets client must have an `info` object with property `title`');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(client.info, 'description')) {
+    throw new Error('targets client must have an `info` object with property `description`');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(client.info, 'link')) {
+    throw new Error('targets client must have an `info` object with property `link`');
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(client, 'convert') || typeof client.convert !== 'function') {
+    throw new Error('targets client must have a `convert` property containing a conversion function');
+  }
+
+  return true;
+};
+
+export const addTargetClient = (targetId: TargetId, client: Client) => {
+  if (!isClient(client)) {
+    return;
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(targets, targetId)) {
+    throw new Error(`Sorry, but no ${targetId} target exists to add clients to`);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(targets[targetId], client.info.key)) {
+    throw new Error(
+      `the target ${targetId} already has a client with the key ${client.info.key}, please use a different key`
+    );
+  }
+
+  targets[targetId].clientsById[client.info.key] = client;
+};

package/src/helpers/code-builder.js

@@ -1,108 +0,0 @@
-/* eslint-disable no-param-reassign */
-const { format } = require('util');
-
-/**
- * Helper object to format and aggragate lines of code.
- * Lines are aggregated in a `code` array, and need to be joined to obtain a proper code snippet.
- *
- * @class
- *
- * @param {string} indentation Desired indentation character for aggregated lines of code
- * @param {string} join Desired character to join each line of code
- */
-class CodeBuilder {
-  constructor(indentation, join) {
-    this.code = [];
-    this.indentation = indentation;
-    this.lineJoin = join || '\n';
-  }
-
-  /**
-   * Add given indentation level to given string and format the string (variadic)
-   * @param {number} [indentationLevel=0] - Desired level of indentation for this line
-   * @param {string} line - Line of code. Can contain formatting placeholders
-   * @param {...anyobject} - Parameter to bind to `line`'s formatting placeholders
-   * @return {string}
-   *
-   * @example
-   *   var builder = CodeBuilder('\t')
-   *
-   *   builder.buildLine('console.log("hello world")')
-   *   // returns: 'console.log("hello world")'
-   *
-   *   builder.buildLine(2, 'console.log("hello world")')
-   *   // returns: 'console.log("\t\thello world")'
-   *
-   *   builder.buildLine(2, 'console.log("%s %s")', 'hello', 'world')
-   *   // returns: 'console.log("\t\thello world")'
-   */
-  buildLine(indentationLevel, line) {
-    let lineIndentation = '';
-    let slice = 2;
-    if (Object.prototype.toString.call(indentationLevel) === '[object String]') {
-      slice = 1;
-      line = indentationLevel;
-      indentationLevel = 0;
-    } else if (indentationLevel === null) {
-      return null;
-    }
-
-    while (indentationLevel) {
-      lineIndentation += this.indentation;
-      // eslint-disable-next-line no-plusplus
-      indentationLevel--;
-    }
-
-    // eslint-disable-next-line prefer-rest-params
-    const data = Array.prototype.slice.call(arguments, slice, arguments.length);
-    data.unshift(lineIndentation + line);
-
-    return format.apply(this, data);
-  }
-
-  /**
-   * Invoke buildLine() and add the line at the top of current lines
-   * @param {number} [indentationLevel=0] Desired level of indentation for this line
-   * @param {string} line Line of code
-   * @return {this}
-   */
-  unshift(...args) {
-    // eslint-disable-next-line prefer-spread
-    this.code.unshift(this.buildLine.apply(this, args));
-
-    return this;
-  }
-
-  /**
-   * Invoke buildLine() and add the line at the bottom of current lines
-   * @param {number} [indentationLevel=0] Desired level of indentation for this line
-   * @param {string} line Line of code
-   * @return {this}
-   */
-  push(...args) {
-    // eslint-disable-next-line prefer-spread
-    this.code.push(this.buildLine.apply(this, args));
-
-    return this;
-  }
-
-  /**
-   * Add an empty line at the end of current lines
-   * @return {this}
-   */
-  blank() {
-    this.code.push(null);
-
-    return this;
-  }
-
-  /**
-   * Concatenate all current lines using the given lineJoin
-   * @return {string}
-   */
-  join() {
-    return this.code.join(this.lineJoin);
-  }
-}
-
-module.exports = CodeBuilder;

package/src/helpers/headers.js

@@ -1,48 +0,0 @@
-module.exports = {
-  /**
-   * Given a headers object retrieve the contents of a header out of it via a case-insensitive key.
-   *
-   * @param {object} headers
-   * @param {string} name
-   * @return {string}
-   */
-  getHeader: (headers, name) => {
-    return headers[Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase())];
-  },
-
-  /**
-   * Given a headers object retrieve a specific header out of it via a case-insensitive key.
-   *
-   * @param {object} headers
-   * @param {string} name
-   * @return {string}
-   */
-  getHeaderName: (headers, name) => {
-    return Object.keys(headers).find(k => {
-      return k.toLowerCase() === name.toLowerCase();
-    });
-  },
-
-  /**
-   * Determine if a given case-insensitive header exists within a header object.
-   *
-   * @param {object} headers
-   * @param {string} name
-   * @return {(integer|boolean)}
-   */
-  hasHeader: (headers, name) => {
-    return Boolean(Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase()));
-  },
-
-  /**
-   * Determines if a given mimetype is JSON, or a variant of such.
-   *
-   * @param {string}} mimeType
-   * @returns {boolean}
-   */
-  isMimeTypeJson: mimeType => {
-    return ['application/json', 'application/x-json', 'text/json', 'text/x-json', '+json'].some(function (type) {
-      return mimeType.indexOf(type) > -1;
-    });
-  },
-};

package/src/helpers/reducer.js

@@ -1,20 +0,0 @@
-/* eslint-disable no-param-reassign */
-module.exports = function (obj, pair) {
-  if (obj[pair.name] === undefined) {
-    obj[pair.name] = pair.value;
-    return obj;
-  }
-
-  // If we already have it as array just push the value
-  if (Array.isArray(obj[pair.name])) {
-    obj[pair.name].push(pair.value);
-    return obj;
-  }
-
-  // convert to array
-  const arr = [obj[pair.name], pair.value];
-
-  obj[pair.name] = arr;
-
-  return obj;
-};