0z2i6v3u5t 1.0.0

package/src/config/logger.ts

@@ -0,0 +1,113 @@
+import * as winston from "winston";
+import { ActionheroConfigInterface } from "..";
+
+const namespace = "logger";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+/*
+The loggers defined here will eventually be available via `import { loggers } from "actionhero"`
+
+You may want to customize how Actionhero sets the log level.  By default, you can use `process.env.LOG_LEVEL` to change each logger's level (default: 'info')
+
+learn more about winston v3 loggers @
+ - https://github.com/winstonjs/winston
+ - https://github.com/winstonjs/winston/blob/master/docs/transports.md
+*/
+
+type ActionheroConfigLoggerBuilderArray = Array<
+  (config: ActionheroConfigInterface) => winston.Logger
+>;
+
+export const DEFAULT = {
+  [namespace]: (config: ActionheroConfigInterface) => {
+    const loggers: ActionheroConfigLoggerBuilderArray = [];
+    loggers.push(buildConsoleLogger(process.env.LOG_LEVEL));
+    config.general.paths.log.forEach((p: string) => {
+      loggers.push(buildFileLogger(p, process.env.LOG_LEVEL));
+    });
+
+    return {
+      loggers,
+      maxLogStringLength: 100, // the maximum length of param to log (we will truncate)
+      maxLogArrayLength: 10, // the maximum number of items in an array to log before collapsing into one message
+    };
+  },
+};
+
+export const test = {
+  [namespace]: (config: ActionheroConfigInterface) => {
+    const loggers: ActionheroConfigLoggerBuilderArray = [];
+    loggers.push(buildConsoleLogger(process.env.LOG_LEVEL ?? "crit"));
+    config.general.paths.log.forEach((path: string) => {
+      loggers.push(buildFileLogger(path, "debug", 1));
+    });
+
+    return { loggers };
+  },
+};
+
+// helpers for building the winston loggers
+
+function buildConsoleLogger(level = "info") {
+  return function () {
+    return winston.createLogger({
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.colorize(),
+        winston.format.printf((info) => {
+          return `${info.timestamp} - ${info.level}: ${
+            info.message
+          } ${stringifyExtraMessagePropertiesForConsole(info)}`;
+        }),
+      ),
+      level,
+      levels: winston.config.syslog.levels,
+      transports: [new winston.transports.Console()],
+    });
+  };
+}
+
+function buildFileLogger(path: string, level = "info", maxFiles?: number) {
+  return function (config: ActionheroConfigInterface) {
+    const filename = `${path}/${config.process.id}-${config.process.env}.log`;
+    return winston.createLogger({
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json(),
+      ),
+      level,
+      levels: winston.config.syslog.levels,
+      transports: [
+        new winston.transports.File({
+          filename,
+          maxFiles,
+        }),
+      ],
+    });
+  };
+}
+
+function stringifyExtraMessagePropertiesForConsole(
+  info: winston.Logform.TransformableInfo,
+) {
+  const skippedProperties = ["message", "timestamp", "level"];
+  let response = "";
+
+  for (const key in info) {
+    const value = info[key];
+    if (skippedProperties.includes(key)) {
+      continue;
+    }
+    if (value === undefined || value === null || value === "") {
+      continue;
+    }
+    response += `${key}=${value} `;
+  }
+
+  return response;
+}

package/src/config/plugins.ts

@@ -0,0 +1,37 @@
+import { PluginConfig } from "..";
+
+const namespace = "plugins";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+export const DEFAULT: { [namespace]: () => PluginConfig } = {
+  [namespace]: () => {
+    /*
+    If you want to use plugins in your application, include them here:
+
+    return {
+      'myPlugin': { path: __dirname + '/../node_modules/myPlugin' }
+    }
+
+    You can also toggle on or off sections of a plugin to include (default true for all sections):
+
+    return {
+      'myPlugin': {
+        path: __dirname + '/../node_modules/myPlugin',
+        actions: true,
+        tasks: true,
+        initializers: true,
+        servers: true,
+        public: true,
+        cli: true
+      }
+    }
+    */
+
+    return {};
+  },
+};

package/src/config/redis.ts

@@ -0,0 +1,78 @@
+import { URL } from "url";
+
+const namespace = "redis";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+/**
+ * This is the standard redis config for Actionhero.
+ * This will use a redis server to persist cache, share chat message between processes, etc.
+ */
+
+export const DEFAULT = {
+  [namespace]: () => {
+    const konstructor = require("ioredis"); // or konstructor = require("ioredis-mock") if you don't need real redis;
+    let protocol = process.env.REDIS_SSL ? "rediss" : "redis";
+    let host = process.env.REDIS_HOST || "127.0.0.1";
+    let port = process.env.REDIS_PORT || 6379;
+    let db = process.env.REDIS_DB || process.env.JEST_WORKER_ID || "0";
+    let password = process.env.REDIS_PASSWORD || null;
+
+    if (process.env.REDIS_URL) {
+      const parsed = new URL(process.env.REDIS_URL);
+      if (parsed.protocol) protocol = parsed.protocol.split(":")[0];
+      if (parsed.password) password = parsed.password;
+      if (parsed.hostname) host = parsed.hostname;
+      if (parsed.port) port = parsed.port;
+      if (parsed.pathname) db = parsed.pathname.substring(1);
+    }
+
+    const maxBackoff = 1000;
+    const commonArgs = {
+      port,
+      host,
+      password,
+      db: parseInt(db),
+      // ssl options
+      tls: protocol === "rediss" ? { rejectUnauthorized: false } : undefined,
+      // you can learn more about retryStrategy @ https://github.com/luin/ioredis#auto-reconnect
+      retryStrategy: (times: number) => {
+        if (times === 1) {
+          console.error(
+            "Unable to connect to Redis - please check your Redis config!",
+          );
+          return 5000;
+        }
+        return Math.min(times * 50, maxBackoff);
+      },
+    };
+
+    return {
+      // how many items should be fetched in a batch at once?
+      scanCount: 1000,
+      // how many ms should we wait when disconnecting after sending server-side disconnect message to the cluster
+      stopTimeout: 100,
+
+      _toExpand: false,
+      client: {
+        konstructor,
+        args: [commonArgs],
+        buildNew: true,
+      },
+      subscriber: {
+        konstructor,
+        args: [commonArgs],
+        buildNew: true,
+      },
+      tasks: {
+        konstructor,
+        args: [commonArgs],
+        buildNew: true,
+      },
+    };
+  },
+};

package/src/config/routes.ts

@@ -0,0 +1,44 @@
+import { RoutesConfig } from "..";
+
+const namespace = "routes";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+export const DEFAULT: { [namespace]: () => RoutesConfig } = {
+  [namespace]: () => {
+    return {
+      get: [
+        { path: "/status", action: "status" },
+        { path: "/swagger", action: "swagger" },
+        { path: "/createChatRoom", action: "createChatRoom" },
+      ],
+
+      /* ---------------------
+      For web clients (http and https) you can define an optional RESTful mapping to help route requests to actions.
+      If the client doesn't specify and action in a param, and the base route isn't a named action, the action will attempt to be discerned from this routes.js file.
+
+      Learn more here: https://www.actionherojs.com/tutorials/web-server#Routes
+
+      examples:
+
+      get: [
+        { path: '/users', action: 'usersList' }, // (GET) /api/users
+        { path: '/search/:term/limit/:limit/offset/:offset', action: 'search' }, // (GET) /api/search/car/limit/10/offset/100
+      ],
+
+      post: [
+        { path: '/login/:userID(^\\d{3}$)', action: 'login' } // (POST) /api/login/123
+      ],
+
+      all: [
+        { path: '/user/:userID', action: 'user', matchTrailingPathParts: true } // (*) /api/user/123, api/user/123/stuff
+      ]
+
+      ---------------------- */
+    };
+  },
+};

package/src/config/tasks.ts

@@ -0,0 +1,84 @@
+import { ActionheroLogLevel } from "..";
+import { MultiWorker, Queue, Scheduler } from "node-resque";
+
+const namespace = "tasks";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+export const DEFAULT = {
+  [namespace]: () => {
+    return {
+      _toExpand: false,
+
+      // Should this node run a scheduler to promote delayed tasks?
+      scheduler: false,
+
+      // what queues should the taskProcessors work?
+      queues: ["*"] as string[] | (() => Promise<string[]>),
+      // Or, rather than providing a static list of `queues`, you can define a method that returns the list of queues.
+      // queues: async () => { return ["queueA", "queueB"]; } as string[] | (() => Promise<string[]>)>,
+
+      // Logging levels of task workers
+      workerLogging: {
+        failure: "error" as ActionheroLogLevel, // task failure
+        success: "info" as ActionheroLogLevel, // task success
+        start: "info" as ActionheroLogLevel,
+        end: "info" as ActionheroLogLevel,
+        cleaning_worker: "info" as ActionheroLogLevel,
+        poll: "debug" as ActionheroLogLevel,
+        job: "debug" as ActionheroLogLevel,
+        pause: "debug" as ActionheroLogLevel,
+        reEnqueue: "debug" as ActionheroLogLevel,
+        internalError: "error" as ActionheroLogLevel,
+        multiWorkerAction: "debug" as ActionheroLogLevel,
+      },
+      // Logging levels of the task scheduler
+      schedulerLogging: {
+        start: "info" as ActionheroLogLevel,
+        end: "info" as ActionheroLogLevel,
+        poll: "debug" as ActionheroLogLevel,
+        enqueue: "debug" as ActionheroLogLevel,
+        working_timestamp: "debug" as ActionheroLogLevel,
+        reEnqueue: "debug" as ActionheroLogLevel,
+        transferred_job: "debug" as ActionheroLogLevel,
+      },
+      // how long to sleep between jobs / scheduler checks
+      timeout: 5000,
+      // at minimum, how many parallel taskProcessors should this node spawn?
+      // (have number > 0 to enable, and < 1 to disable)
+      minTaskProcessors: 0,
+      // at maximum, how many parallel taskProcessors should this node spawn?
+      maxTaskProcessors: 0,
+      // how often should we check the event loop to spawn more taskProcessors?
+      checkTimeout: 500,
+      // how many ms would constitute an event loop delay to halt taskProcessors spawning?
+      maxEventLoopDelay: 5,
+      // how long before we mark a resque worker / task processor as stuck/dead?
+      stuckWorkerTimeout: 1000 * 60 * 60,
+      // should the scheduler automatically try to retry failed tasks which were failed due to being 'stuck'?
+      retryStuckJobs: false,
+      // Customize Resque primitives, replace null with required replacement.
+      resque_overrides: {
+        queue: null as Queue,
+        multiWorker: null as MultiWorker,
+        scheduler: null as Scheduler,
+      },
+      connectionOptions: {
+        tasks: {},
+      },
+    };
+  },
+};
+
+export const test = {
+  [namespace]: () => {
+    return {
+      timeout: 100,
+      checkTimeout: 50,
+    };
+  },
+};

package/src/config/web.ts

@@ -0,0 +1,136 @@
+import * as os from "os";
+import { ActionheroConfigInterface } from "..";
+
+import type { Options as FormParserOptions } from "formidable";
+
+const namespace = "web";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+export const DEFAULT = {
+  [namespace]: (config: ActionheroConfigInterface) => {
+    return {
+      enabled: true,
+      // HTTP or HTTPS?  This setting is to enable SSL termination directly in the actionhero app, not set redirection host headers
+      secure: false,
+      // Passed to https.createServer if secure=true. Should contain SSL certificates
+      serverOptions: {},
+      // Should we redirect all traffic to the first host in this array if hte request header doesn't match?
+      // i.e.: [ 'https://www.site.com' ]
+      allowedRequestHosts: process.env.ALLOWED_HOSTS
+        ? process.env.ALLOWED_HOSTS.split(",")
+        : [],
+      // Port or Socket Path
+      port: process.env.PORT || 8080,
+      // Which IP to listen on (use '0.0.0.0' for the default ip stack; '::' for all on ipv4 and ipv6)
+      // Set to `null` when listening to socket
+      bindIP: "::",
+      // Any additional headers you want actionhero to respond with
+      httpHeaders: {
+        "X-Powered-By": config.general.serverName,
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods":
+          "HEAD, GET, POST, PUT, PATCH, DELETE, OPTIONS, TRACE",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Strict-Transport-Security": "max-age=31536000; includeSubDomains",
+      },
+      // Route that actions will be served from; secondary route against this route will be treated as actions,
+      //  IE: /api/?action=test == /api/test/
+      urlPathForActions: "api",
+      // Route that static files will be served from;
+      //  path (relative to your project root) to serve static content from
+      //  set to `null` to disable the file server entirely
+      urlPathForFiles: "public",
+      // When visiting the root URL, should visitors see 'api' or 'file'?
+      //  Visitors can always visit /api and /public as normal
+      rootEndpointType: "file",
+      // In addition to what's defined in config/routes.ts, should we make a route for every action?  Useful for debugging or simple APIs.
+      // automaticRoutes should an array of strings - HTTP verbs, ie: [] (default), ['get'], ['post'], ['get','put'], ['get','post','put'], etc.
+      automaticRoutes: process.env.AUTOMATIC_ROUTES
+        ? process.env.AUTOMATIC_ROUTES.split(",")
+            .map((v) => v.trim())
+            .map((v) => v.toLowerCase())
+        : [],
+      // Default HTTP status code for errors thrown in an action
+      defaultErrorStatusCode: 500,
+      // The cache or (if etags are enabled) next-revalidation time to be returned for all flat files served from /public; defined in seconds
+      flatFileCacheDuration: 60,
+      // Add an etag header to requested flat files which acts as fingerprint that changes when the file is updated;
+      // Client will revalidate the fingerprint at latest after flatFileCacheDuration and reload it if the etag (and therefore the file) changed
+      // or continue to use the cached file if it's still valid
+      enableEtag: true,
+      // should we save the un-parsed HTTP POST/PUT payload to connection.rawConnection.params.rawBody?
+      saveRawBody: false,
+      // How many times should we try to boot the server?
+      // This might happen if the port is in use by another process or the socket file is claimed
+      bootAttempts: 1,
+      // Settings for determining the id of an http(s) request (browser-fingerprint)
+      fingerprintOptions: {
+        cookieKey: "sessionID",
+        toSetCookie: true,
+        onlyStaticElements: false,
+        settings: {
+          path: "/",
+          expires: 3600000,
+        },
+      },
+      // Options to be applied to incoming file uploads.
+      //  More options and details at https://github.com/felixge/node-formidable
+      formOptions: {
+        uploadDir: os.tmpdir(),
+        keepExtensions: false,
+        maxFieldsSize: 1024 * 1024 * 20,
+        maxFileSize: 1024 * 1024 * 200,
+      } as FormParserOptions,
+      // Should we pad JSON responses with whitespace to make them more human-readable?
+      // set to null to disable
+      padding: 2,
+      // Options to configure metadata in responses
+      metadataOptions: {
+        serverInformation: true,
+        requesterInformation: true,
+      },
+      // When true, returnErrorCodes will modify the response header for http(s) clients if connection.error is not null.
+      // You can also set connection.rawConnection.responseHttpCode to specify a code per request.
+      returnErrorCodes: true,
+      // should this node server attempt to gzip responses if the client can accept them?
+      // this will slow down the performance of actionhero, and if you need this functionality, it is recommended that you do this upstream with nginx or your load balancer
+      compress: false,
+      // options to pass to the query parser
+      // learn more about the options @ https://github.com/hapijs/qs
+      queryParseOptions: {},
+    };
+  },
+};
+
+export const production = {
+  [namespace]: () => {
+    return {
+      padding: null as number,
+      metadataOptions: {
+        serverInformation: false,
+        requesterInformation: false,
+      },
+    };
+  },
+};
+
+export const test = {
+  [namespace]: () => {
+    return {
+      secure: false,
+      port: process.env.PORT
+        ? process.env.PORT
+        : 18080 + parseInt(process.env.JEST_WORKER_ID || "0"),
+      matchExtensionMime: true,
+      metadataOptions: {
+        serverInformation: true,
+        requesterInformation: true,
+      },
+    };
+  },
+};

package/src/config/websocket.ts

@@ -0,0 +1,62 @@
+// Note that to use the websocket server, you also need the web server enabled
+
+import { ActionheroConfigInterface } from "..";
+
+const namespace = "websocket";
+
+declare module ".." {
+  export interface ActionheroConfigInterface {
+    [namespace]: ReturnType<(typeof DEFAULT)[typeof namespace]>;
+  }
+}
+
+export const DEFAULT = {
+  [namespace]: (config: ActionheroConfigInterface) => {
+    return {
+      enabled: true,
+      // you can pass a FQDN (like https://company.com) here or 'window.location.origin'
+      clientUrl: "window.location.origin",
+      // Directory to render client-side JS.
+      // Path should start with "/" and will be built starting from api.config..general.paths.public
+      clientJsPath: "javascript/",
+      // the name of the client-side JS file to render.  Both `.js` and `.min.js` versions will be created
+      // do not include the file extension
+      // set to `undefined` to not render the client-side JS on boot
+      clientJsName: "ActionheroWebsocketClient",
+      // should the server signal clients to not reconnect when the server is shutdown/reboot
+      destroyClientsOnShutdown: false,
+
+      // websocket Server Options:
+      server: {
+        // authorization: null,
+        // pathname:      '/primus',
+        // parser:        'JSON',
+        // transformer:   'websockets',
+        // plugin:        {},
+        // timeout:       35000,
+        // origins:       '*',
+        // methods:       ['GET','HEAD','PUT','POST','DELETE','OPTIONS'],
+        // credentials:   true,
+        // maxAge:        '30 days',
+        // exposed:       false,
+      },
+
+      // websocket Client Options:
+      client: {
+        apiPath: "/api", // the api base endpoint on your actionhero server
+        // the cookie name we should use for shared authentication between WS and web connections
+        cookieKey: config.web.fingerprintOptions.cookieKey,
+        // reconnect:        {},
+        // timeout:          10000,
+        // ping:             25000,
+        // pong:             10000,
+        // strategy:         "online",
+        // manual:           false,
+        // websockets:       true,
+        // network:          true,
+        // transport:        {},
+        // queueSize:        Infinity,
+      },
+    };
+  },
+};

package/src/index.ts

@@ -0,0 +1,46 @@
+// export classes (capitalized)
+export { Api } from "./classes/api";
+export { Process } from "./classes/process";
+export { ActionheroConfigInterface } from "./classes/config";
+export { Initializer } from "./classes/initializer";
+export { Connection } from "./classes/connection";
+export { ExceptionReporter } from "./classes/exceptionReporter";
+export { Action } from "./classes/action";
+export { Task } from "./classes/task";
+export { Server } from "./classes/server";
+export { CLI } from "./classes/cli";
+export { ActionProcessor } from "./classes/actionProcessor";
+export { PluginConfig } from "./classes/config";
+export { Inputs, ParamsFrom } from "./classes/inputs";
+export { Input } from "./classes/input";
+
+// export modules (lower case)
+export { utils } from "./modules/utils";
+export { config, rebuildConfig } from "./modules/config";
+export { log, loggers, ActionheroLogLevel } from "./modules/log";
+export { action } from "./modules/action";
+export { task } from "./modules/task";
+export { cache } from "./modules/cache";
+export { chatRoom } from "./modules/chatRoom";
+export { redis } from "./modules/redis";
+export { route, RouteMethod, RouteType, RoutesConfig } from "./modules/route";
+export { specHelper } from "./modules/specHelper";
+
+// export static members of this process (lower case)
+export { env } from "./classes/process/env";
+export { actionheroVersion } from "./classes/process/actionheroVersion";
+export { projectRoot } from "./classes/process/projectRoot";
+export { typescript } from "./classes/process/typescript";
+export { id } from "./classes/process/id";
+
+// API object to hold connections, actions, tasks, initializers, and servers
+import { Api } from "./classes/api";
+
+// export a global API instance
+
+declare module globalThis {
+  let api: Api;
+}
+
+if (!globalThis.api) globalThis.api = new Api();
+export const api = globalThis.api;