0z2i6v3u5t 1.0.0

package/src/modules/utils/fileUtils.ts

@@ -0,0 +1,119 @@
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * Check if a directory exists.
+ */
+export function dirExists(dir: string): boolean {
+  try {
+    const stats = fs.lstatSync(dir);
+    return stats.isDirectory() || stats.isSymbolicLink();
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Check if a file exists.
+ */
+export function fileExists(file: string): boolean {
+  try {
+    const stats = fs.lstatSync(file);
+    return stats.isFile() || stats.isSymbolicLink();
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Create a directory, only if it doesn't exist yet.
+ * Throws an error if the directory already exists, or encounters a filesystem problem.
+ */
+export function createDirSafely(dir: string): string {
+  if (dirExists(dir)) {
+    const error = new Error(
+      `directory '${path.normalize(dir)}' already exists`,
+    );
+    // @ts-ignore
+    error.code = "EEXIST";
+    throw error;
+  } else {
+    fs.mkdirSync(path.normalize(dir), "0766");
+    return `created directory '${path.normalize(dir)}'`;
+  }
+}
+
+/**
+ * Create a file, only if it doesn't exist yet.
+ * Throws an error if the file already exists, or encounters a filesystem problem.
+ */
+export function createFileSafely(
+  file: string,
+  data: string | NodeJS.ArrayBufferView,
+  overwrite: boolean = false,
+): string {
+  if (fileExists(file) && !overwrite) {
+    const error = new Error(`file '${path.normalize(file)}' already exists`);
+    // @ts-ignore
+    error.code = "EEXIST";
+    throw error;
+  } else {
+    let message = `wrote file '${path.normalize(file)}'`;
+    if (overwrite && fileExists(file)) {
+      message = ` - overwritten file '${path.normalize(file)}'`;
+    }
+    fs.writeFileSync(path.normalize(file), data);
+    return message;
+  }
+}
+
+/**
+ * Create an Actionhero LinkFile, only if it doesn't exist yet.
+ * Throws an error if the file already exists, or encounters a filesystem problem.
+ */
+export function createLinkfileSafely(filePath: string, type: string): string {
+  if (fileExists(filePath)) {
+    const error = new Error(`link file '${filePath}' already exists`);
+    // @ts-ignore
+    error.code = "EEXIST";
+    throw error;
+  } else {
+    fs.writeFileSync(filePath, type);
+    return `creating linkfile '${filePath}'`;
+  }
+}
+
+/**
+ * Remove an Actionhero LinkFile, only if it exists.
+ * Throws an error if the file does not exist, or encounters a filesystem problem.
+ */
+export function removeLinkfileSafely(filePath: string): string {
+  if (!fileExists(filePath)) {
+    const error = new Error(`link file '${filePath}' doesn't exist`);
+    // @ts-ignore
+    error.code = "ENOEXIST";
+    throw error;
+  } else {
+    fs.unlinkSync(filePath);
+    return `removing linkfile '${filePath}'`;
+  }
+}
+
+/**
+ * Create a system symbolic link.
+ * Throws an error if it encounters a filesystem problem.
+ */
+export function createSymlinkSafely(
+  destination: string,
+  source: string,
+): string {
+  if (dirExists(destination)) {
+    const error = new Error(`symbolic link '${destination}' already exists`);
+    // @ts-ignore
+    error.code = "EEXIST";
+    throw error;
+  } else {
+    fs.symlinkSync(source, destination, "dir");
+    return `creating symbolic link '${destination}' => '${source}'`;
+  }
+}

package/src/modules/utils/filterObjectForLogging.ts

@@ -0,0 +1,51 @@
+import { isPlainObject } from "./isPlainObject";
+import { deepCopy } from "./deepCopy";
+import { config } from "../config";
+import * as dotProp from "dot-prop";
+
+/**
+ * Prepares acton params for logging.
+ * Hides any sensitive data as defined by `api.config.general.filteredParams`
+ * Truncates long strings via `api.config.logger.maxLogStringLength`
+ */
+export function filterObjectForLogging(
+  params: Record<string, any>,
+): Record<string, any> {
+  params = deepCopy(params);
+  const sanitizedParams: Record<string, any> = {};
+
+  for (const i in params) {
+    if (
+      Array.isArray(params[i]) &&
+      params[i].length > (config.logger?.maxLogArrayLength ?? 10)
+    ) {
+      params[i] = `${params[i].length} items`;
+    }
+
+    if (isPlainObject(params[i])) {
+      sanitizedParams[i] = params[i];
+    } else if (typeof params[i] === "string") {
+      sanitizedParams[i] = params[i].substring(
+        0,
+        config.logger.maxLogStringLength,
+      );
+    } else {
+      sanitizedParams[i] = params[i];
+    }
+  }
+
+  let filteredParams: string[];
+  if (typeof config.general.filteredParams === "function") {
+    filteredParams = config.general.filteredParams();
+  } else {
+    filteredParams = config.general.filteredParams;
+  }
+
+  filteredParams.forEach((configParam) => {
+    if (dotProp.get(params, configParam) !== undefined) {
+      dotProp.set(sanitizedParams, configParam, "[FILTERED]");
+    }
+  });
+
+  return sanitizedParams;
+}

package/src/modules/utils/filterResponseForLogging.ts

@@ -0,0 +1,53 @@
+import { isPlainObject } from "./isPlainObject";
+import { deepCopy } from "./deepCopy";
+import { config } from "../config";
+import * as dotProp from "dot-prop";
+
+/**
+ * Prepares acton response for logging.
+ * Hides any sensitive data as defined by `api.config.general.filteredResponse`
+ * Truncates long strings via `api.config.logger.maxLogStringLength`
+ */
+export function filterResponseForLogging(response: Record<string, any>): {
+  [key: string]: any;
+} {
+  response = deepCopy(response);
+  const sanitizedResponse: Record<string, any> = {};
+
+  for (const i in response) {
+    if (
+      Array.isArray(response[i]) &&
+      response[i].length > (config.logger?.maxLogArrayLength ?? 10)
+    ) {
+      response[i] = `${response[i].length} items`;
+    }
+
+    if (isPlainObject(response[i])) {
+      sanitizedResponse[i] = response[i];
+    } else if (typeof response[i] === "string") {
+      sanitizedResponse[i] = response[i].substring(
+        0,
+        config.logger.maxLogStringLength,
+      );
+    } else if (response[i] instanceof Error) {
+      sanitizedResponse[i] = response[i].message ?? String(response[i]);
+    } else {
+      sanitizedResponse[i] = response[i];
+    }
+  }
+
+  let filteredResponse: string[];
+  if (typeof config.general.filteredResponse === "function") {
+    filteredResponse = config.general.filteredResponse();
+  } else {
+    filteredResponse = config.general.filteredResponse;
+  }
+
+  filteredResponse.forEach((configParam) => {
+    if (dotProp.get(response, configParam) !== undefined) {
+      dotProp.set(sanitizedResponse, configParam, "[FILTERED]");
+    }
+  });
+
+  return sanitizedResponse;
+}

package/src/modules/utils/getExternalIPAddress.ts

@@ -0,0 +1,17 @@
+import * as os from "os";
+
+/**
+ * Returns this server's external/public IP address
+ */
+export function getExternalIPAddress(): string {
+  const interfaces = os.networkInterfaces();
+  let ip = null;
+  for (const dev in interfaces) {
+    interfaces[dev].forEach((details) => {
+      if (details.family === "IPv4" && details.address !== "127.0.0.1") {
+        ip = details.address;
+      }
+    });
+  }
+  return ip;
+}

package/src/modules/utils/hashMerge.ts

@@ -0,0 +1,63 @@
+import { isPlainObject } from "./isPlainObject";
+
+/**
+ * Recursively merge 2 Objects together.  Will resolve functions if they are present, unless the parent Object has the property `_toExpand = false`.
+ * Actionhero uses this internally to construct and resolve the config.
+ * Matching keys in B override A.
+ */
+export function hashMerge(
+  a: Record<string, any>,
+  b: Record<string, any>,
+  arg?: Record<string, any>,
+): { [key: string]: any } {
+  const c: Record<string, any> = {};
+  let i: string;
+  let response: object;
+
+  for (i in a) {
+    if (isPlainObject(a[i])) {
+      // can't be added into above condition, or empty objects will overwrite and not merge
+      // also make sure empty objects are created
+      c[i] = Object.keys(a[i]).length > 0 ? hashMerge(c[i], a[i], arg) : {};
+    } else {
+      if (typeof a[i] === "function") {
+        response = a[i](arg);
+        if (isPlainObject(response)) {
+          c[i] = hashMerge(c[i], response, arg);
+        } else {
+          c[i] = response;
+        }
+      } else {
+        // don't create first term if it is undefined or null
+        if (a[i] === undefined || a[i] === null) {
+        } else c[i] = a[i];
+      }
+    }
+  }
+  for (i in b) {
+    if (isPlainObject(b[i])) {
+      // can't be added into above condition, or empty objects will overwrite and not merge
+      if (Object.keys(b[i]).length > 0) c[i] = hashMerge(c[i], b[i], arg);
+      // make sure empty objects are only created, when no key exists yet
+      else if (!(i in c)) c[i] = {};
+    } else {
+      if (typeof b[i] === "function") {
+        response = b[i](arg);
+        if (isPlainObject(response)) {
+          c[i] = hashMerge(c[i], response, arg);
+        } else {
+          c[i] = response;
+        }
+      } else {
+        // ignore second term if it is undefined
+        if (b[i] === undefined) {
+        } else if (b[i] == null && i in c)
+          // delete second term/key if value is null and it already exists
+          delete c[i];
+        // normal assignments for everything else
+        else c[i] = b[i];
+      }
+    }
+  }
+  return c;
+}

package/src/modules/utils/isPlainObject.ts

@@ -0,0 +1,45 @@
+/**
+ * Is the JS Object passed in truly just an object?
+ */
+export function isPlainObject(o: any) {
+  const safeTypes = [
+    Boolean,
+    Number,
+    String,
+    Function,
+    Array,
+    Date,
+    RegExp,
+    Buffer,
+  ];
+  const safeInstances = ["boolean", "number", "string", "function"];
+  const expandPreventMatchKey = "_toExpand"; // set `_toExpand = false` within an object if you don't want to expand it
+  let i;
+
+  if (!o) {
+    return false;
+  }
+  if (o instanceof Object === false) {
+    return false;
+  }
+  for (i in safeTypes) {
+    if (o instanceof safeTypes[i]) {
+      return false;
+    }
+  }
+  for (i in safeInstances) {
+    if (typeof o === safeInstances[i]) {
+      return false;
+    }
+  }
+  if (o[expandPreventMatchKey] === false) {
+    return false;
+  }
+
+  try {
+    // sometimes objects cannot be successfully stringified (https://github.com/node-formidable/formidable/pull/796)
+    return o.toString() === "[object Object]";
+  } catch (error) {
+    return true;
+  }
+}

package/src/modules/utils/isRunning.ts

@@ -0,0 +1,7 @@
+export function isRunning(pid: number) {
+  try {
+    return process.kill(pid, 0);
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}

package/src/modules/utils/parseCookies.ts

@@ -0,0 +1,20 @@
+/**
+ * Transform the cookie headers of a node HTTP `req` Object into a hash.
+ */
+export function parseCookies(req: {
+  headers: { [key: string]: string | string[] };
+}): object {
+  const cookies: Record<string, string> = {};
+  if (req.headers.cookie) {
+    (Array.isArray(req.headers.cookie)
+      ? req.headers.cookie.join("")
+      : req.headers.cookie
+    )
+      .split(";")
+      .forEach((cookie) => {
+        const parts = cookie.split("=");
+        cookies[parts[0].trim()] = (parts[1] || "").trim();
+      });
+  }
+  return cookies;
+}

package/src/modules/utils/parseHeadersForClientAddress.ts

@@ -0,0 +1,53 @@
+import { parseIPv6URI } from "./parseIPv6URI";
+
+/**
+ * Return ip and port information if defined in the header
+ */
+export function parseHeadersForClientAddress(
+  headers: Record<string, string | string[]>,
+) {
+  let ip: string;
+  let port: number | string;
+
+  if (headers["x-forwarded-for"]) {
+    let parts;
+    let forwardedIp = Array.isArray(headers["x-forwarded-for"])
+      ? headers["x-forwarded-for"][0].split(",")[0]
+      : headers["x-forwarded-for"].split(",")[0];
+    if (
+      forwardedIp.indexOf(".") >= 0 ||
+      (forwardedIp.indexOf(".") < 0 && forwardedIp.indexOf(":") < 0)
+    ) {
+      // IPv4
+      forwardedIp = forwardedIp.replace("::ffff:", ""); // remove any IPv6 information, ie: '::ffff:127.0.0.1'
+      parts = forwardedIp.split(":");
+      if (parts[0]) {
+        ip = parts[0];
+      }
+      if (parts[1]) {
+        port = parts[1];
+      }
+    } else {
+      // IPv6
+      parts = parseIPv6URI(forwardedIp);
+      if (parts.host) {
+        ip = parts.host;
+      }
+      if (parts.port) {
+        port = parts.port;
+      }
+    }
+  }
+  if (headers["x-forwarded-port"]) {
+    port = Array.isArray(headers["x-forwarded-port"])
+      ? headers["x-forwarded-port"][0]
+      : headers["x-forwarded-port"];
+  }
+  if (headers["x-real-ip"]) {
+    // https://distinctplace.com/2014/04/23/story-behind-x-forwarded-for-and-x-real-ip-headers/
+    ip = Array.isArray(headers["x-real-ip"])
+      ? headers["x-real-ip"][0]
+      : headers["x-real-ip"];
+  }
+  return { ip, port };
+}

package/src/modules/utils/parseIPv6URI.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse an IPv6 address, returning both host and port.
+ * see https://github.com/actionhero/actionhero/issues/275
+ */
+export function parseIPv6URI(addr: string): {
+  host: string;
+  port: number;
+} {
+  let host = "::1";
+  let port = "80";
+  const regexp = new RegExp(/\[([0-9a-f:]+(?:%.+)?)]:([0-9]{1,5})/);
+  // if we have brackets parse them and find a port
+  if (addr.indexOf("[") > -1 && addr.indexOf("]") > -1) {
+    const res = regexp.exec(addr);
+    if (res === null) {
+      throw new Error("failed to parse address");
+    }
+    host = res[1];
+    port = res[2];
+  } else {
+    host = addr;
+  }
+  return { host: host, port: parseInt(port, 10) };
+}

package/src/modules/utils/replaceDistWithSrc.ts

@@ -0,0 +1,9 @@
+import { config } from "../config";
+
+/**
+ * Used by generator functions running from your `dist`, it replaces the path with your `src`
+ * Relies on api.config.general.paths
+ */
+export function replaceDistWithSrc(f: string) {
+  return f.replace(config.general.paths.dist, config.general.paths.src);
+}

package/src/modules/utils/safeGlob.ts

@@ -0,0 +1,6 @@
+import * as glob from "glob";
+
+export function safeGlobSync(match: string, args: glob.IOptions = {}) {
+  const isWindows = process.platform === "win32";
+  return glob.sync(match, { ...args, windowsPathsNoEscape: isWindows });
+}

package/src/modules/utils/sleep.ts

@@ -0,0 +1,8 @@
+/**
+    Sleep with a Promise
+    */
+export function sleep(time: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}

package/src/modules/utils/sortGlobalMiddleware.ts

@@ -0,0 +1,17 @@
+/**
+ * Sorts an Array of Objects with a priority key
+ */
+export function sortGlobalMiddleware(
+  globalMiddlewareList: Array<any>,
+  middleware: {
+    [key: string]: any;
+  },
+) {
+  globalMiddlewareList.sort((a, b) => {
+    if (middleware[a].priority > middleware[b].priority) {
+      return 1;
+    } else {
+      return -1;
+    }
+  });
+}

package/src/modules/utils/sourceRelativeLinkPath.ts

@@ -0,0 +1,29 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export function sourceRelativeLinkPath(
+  linkFile: string,
+  pluginPaths: Array<string>,
+): string | boolean {
+  const type = fs.readFileSync(linkFile).toString();
+  const pathParts = linkFile.split(path.sep);
+  const name = pathParts[pathParts.length - 1].split(".")[0];
+  const pathsToTry = pluginPaths.slice(0);
+  let pluginRoot: string;
+
+  pathsToTry.forEach((pluginPath) => {
+    const pluginPathAttempt = path.normalize(pluginPath + path.sep + name);
+    try {
+      const stats = fs.lstatSync(pluginPathAttempt);
+      if (!pluginRoot && (stats.isDirectory() || stats.isSymbolicLink())) {
+        pluginRoot = pluginPathAttempt;
+      }
+    } catch (e) {}
+  });
+
+  if (!pluginRoot) {
+    return false;
+  }
+  const pluginSection = path.normalize(pluginRoot + path.sep + type);
+  return pluginSection;
+}

package/src/modules/utils.ts

@@ -0,0 +1,66 @@
+import { argv } from "./utils/argv";
+import { arrayStartingMatch } from "./utils/arrayStartingMatch";
+import { arrayUnique } from "./utils/arrayUnique";
+import { collapseObjectToArray } from "./utils/collapseObjectToArray";
+import { deepCopy } from "./utils/deepCopy";
+import { ensureNoTsHeaderOrSpecFiles } from "./utils/ensureNoTsHeaderOrSpecFiles";
+import { eventLoopDelay } from "./utils/eventLoopDelay";
+import { filterObjectForLogging } from "./utils/filterObjectForLogging";
+import { filterResponseForLogging } from "./utils/filterResponseForLogging";
+import { getExternalIPAddress } from "./utils/getExternalIPAddress";
+import { hashMerge } from "./utils/hashMerge";
+import { isPlainObject } from "./utils/isPlainObject";
+import { parseHeadersForClientAddress } from "./utils/parseHeadersForClientAddress";
+import { parseCookies } from "./utils/parseCookies";
+import { parseIPv6URI } from "./utils/parseIPv6URI";
+import { replaceDistWithSrc } from "./utils/replaceDistWithSrc";
+import { sleep } from "./utils/sleep";
+import { sortGlobalMiddleware } from "./utils/sortGlobalMiddleware";
+import { sourceRelativeLinkPath } from "./utils/sourceRelativeLinkPath";
+import {
+  dirExists,
+  fileExists,
+  createDirSafely,
+  createFileSafely,
+  createLinkfileSafely,
+  removeLinkfileSafely,
+  createSymlinkSafely,
+} from "./utils/fileUtils";
+import { isRunning } from "./utils/isRunning";
+import { safeGlobSync } from "./utils/safeGlob";
+
+/**
+ * Utility functions for Actionhero
+ */
+export const utils = {
+  argv,
+  arrayStartingMatch,
+  arrayUnique,
+  collapseObjectToArray,
+  deepCopy,
+  ensureNoTsHeaderOrSpecFiles,
+  eventLoopDelay,
+  filterObjectForLogging,
+  filterResponseForLogging,
+  getExternalIPAddress,
+  hashMerge,
+  isPlainObject,
+  parseHeadersForClientAddress,
+  parseCookies,
+  parseIPv6URI,
+  replaceDistWithSrc,
+  sleep,
+  sortGlobalMiddleware,
+  sourceRelativeLinkPath,
+  fileUtils: {
+    dirExists,
+    fileExists,
+    createDirSafely,
+    createFileSafely,
+    createLinkfileSafely,
+    removeLinkfileSafely,
+    createSymlinkSafely,
+  },
+  safeGlobSync,
+  isRunning,
+};

package/src/server.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+// load any custom code, configure the env, as needed
+
+async function main() {
+  // create a new actionhero process
+  const { Process } = await import("./index");
+  const app = new Process();
+
+  // handle unix signals and uncaught exceptions & rejections
+  app.registerProcessSignals((exitCode) => {
+    process.exit(exitCode);
+  });
+
+  // start the app!
+  // you can pass custom configuration to the process as needed
+  await app.start();
+}
+
+main();