0z2i6v3u5t 1.0.0

package/src/modules/chatRoom.ts

@@ -0,0 +1,321 @@
+import { AsyncReturnType } from "type-fest";
+import { api, config, id, redis, Connection } from "./../index";
+import * as RedisModule from "../modules/redis";
+
+export namespace chatRoom {
+  /**
+   * Middleware definition for processing chat events.  Can be of the
+   *
+   * ```js
+   *  var chatMiddleware = {
+   *    name: 'chat middleware',
+   *    priority: 1000,
+   *    join: (connection, room) => {
+   *      // announce all connections entering a room
+   *      api.chatRoom.broadcast(null, room, 'I have joined the room: ' + connection.id, callback)
+   *    },
+   *    leave:(connection, room, callback) => {
+   *      // announce all connections leaving a room
+   *      api.chatRoom.broadcast(null, room, 'I have left the room: ' + connection.id, callback)
+   *    },
+   *    // Will be executed once per client connection before delivering the message.
+   *    say: (connection, room, messagePayload) => {
+   *      // do stuff
+   *      log(messagePayload)
+   *    },
+   *    // Will be executed only once, when the message is sent to the server.
+   *    onSayReceive: (connection, room, messagePayload) => {
+   *      // do stuff
+   *      log(messagePayload)
+   *    }
+   * }
+   * api.chatRoom.addMiddleware(chatMiddleware)
+   * ```
+   */
+
+  export interface ChatMiddleware {
+    /**Unique name for the middleware. */
+    name: string;
+    /**Module load order. Defaults to `api.config.general.defaultMiddlewarePriority`. */
+    priority?: number;
+    /**Called when a connection joins a room. */
+    join?: Function;
+    /**Called when a connection leaves a room. */
+    leave?: Function;
+    /**Called when a connection says a message to a room. */
+    onSayReceive?: Function;
+    /**Called when a connection is about to receive a say message. */
+    say?: Function;
+  }
+
+  export interface ChatPubSubMessage extends RedisModule.redis.PubSubMessage {
+    messageType: string;
+    serverToken: string;
+    serverId: string | number;
+    message: any;
+    sentAt: number;
+    connection: {
+      id: string;
+      room: string;
+    };
+  }
+
+  export function client() {
+    if (api.redis.clients && api.redis.clients.client) {
+      return api.redis.clients.client;
+    } else {
+      throw new Error("redis not connected, chatRoom cannot be used");
+    }
+  }
+
+  /**
+   * Add a middleware component to connection handling.
+   */
+  export async function addMiddleware(data: ChatMiddleware) {
+    if (!data.name) {
+      throw new Error("middleware.name is required");
+    }
+    if (!data.priority) {
+      data.priority = config.general.defaultMiddlewarePriority;
+    }
+    data.priority = Number(data.priority);
+    api.chatRoom.middleware[data.name] = data;
+
+    api.chatRoom.globalMiddleware.push(data.name);
+    api.chatRoom.globalMiddleware.sort((a, b) => {
+      if (
+        api.chatRoom.middleware[a].priority >
+        api.chatRoom.middleware[b].priority
+      ) {
+        return 1;
+      } else {
+        return -1;
+      }
+    });
+  }
+
+  /**
+   * List all chat rooms created
+   */
+  export async function list(): Promise<Array<string>> {
+    return client().smembers(api.chatRoom.keys.rooms);
+  }
+
+  /**
+   * Add a new chat room.  Throws an error if the room already exists.
+   */
+  export async function add(room: string) {
+    const found = await chatRoom.exists(room);
+    if (found === false) {
+      return client().sadd(api.chatRoom.keys.rooms, room);
+    } else {
+      throw new Error(await config.errors.connectionRoomExists(room));
+    }
+  }
+
+  /**
+   * Remove an existing chat room.  All connections in the room will be removed.  Throws an error if the room does not exist.
+   */
+  export async function destroy(room: string) {
+    const found = await chatRoom.exists(room);
+    if (found === true) {
+      await api.chatRoom.broadcast(
+        null,
+        room,
+        await config.errors.connectionRoomHasBeenDeleted(room),
+      );
+      const membersHash = await client().hgetall(
+        api.chatRoom.keys.members + room,
+      );
+
+      for (const id in membersHash) {
+        await chatRoom.removeMember(id, room, false);
+      }
+
+      await client().srem(api.chatRoom.keys.rooms, room);
+      await client().del(api.chatRoom.keys.members + room);
+    } else {
+      throw new Error(await config.errors.connectionRoomNotExist(room));
+    }
+  }
+
+  /**
+   * Check if a room exists.
+   */
+  export async function exists(room: string): Promise<boolean> {
+    const isMember = await client().sismember(api.chatRoom.keys.rooms, room);
+    let found = false;
+    if (isMember === 1 || isMember.toString() === "true") found = true;
+    return found;
+  }
+
+  /**
+   * Configures what properties of connections in a room to return via `api.chatRoom.roomStatus`
+   */
+  export async function sanitizeMemberDetails(memberData: {
+    id: string;
+    joinedAt: number;
+    [key: string]: any;
+  }) {
+    return {
+      id: memberData.id,
+      joinedAt: memberData.joinedAt,
+    };
+  }
+
+  /**
+   * Learn about the connections in the room.
+   * Returns a hash of the form { room: room, members: cleanedMembers, membersCount: count }.  Members is an array of connections in the room sanitized via `api.chatRoom.sanitizeMemberDetails`
+   */
+  export async function roomStatus(room: string): Promise<{
+    room: string;
+    membersCount: number;
+    members: Record<string, AsyncReturnType<typeof sanitizeMemberDetails>>;
+  }> {
+    if (room) {
+      const found = await chatRoom.exists(room);
+      if (found === true) {
+        const key = api.chatRoom.keys.members + room;
+        const members = (await api.redis.clients.client.hgetall(key)) as {
+          [key: string]: string;
+        };
+        const cleanedMembers: Record<string, any> = {};
+        let count = 0;
+
+        for (const id in members) {
+          const data = JSON.parse(members[id]);
+          cleanedMembers[id] = await chatRoom.sanitizeMemberDetails(data);
+          count++;
+        }
+
+        return {
+          room: room,
+          members: cleanedMembers,
+          membersCount: count,
+        };
+      } else {
+        throw new Error(await config.errors.connectionRoomNotExist(room));
+      }
+    } else {
+      throw new Error(await config.errors.connectionRoomRequired());
+    }
+  }
+
+  /**
+   * An overwrite-able method which configures what properties of connections in a room are initially stored about a connection when added via `api.chatRoom.addMember`
+   */
+  export async function generateMemberDetails(connection: Connection) {
+    return {
+      id: connection.id,
+      joinedAt: new Date().getTime(),
+      host: id,
+    };
+  }
+
+  /**
+   * Add a connection (via id) to a room.  Throws errors if the room does not exist, or the connection is already in the room.  Middleware errors also throw.
+   */
+  export async function addMember(
+    connectionId: string,
+    room: string,
+  ): Promise<any> {
+    const connection = api.connections.connections[connectionId];
+    if (!connection) {
+      return redis.doCluster(
+        "api.chatRoom.addMember",
+        [connectionId, room],
+        connectionId,
+        true,
+      );
+    }
+
+    if (connection.rooms.includes(room)) {
+      throw new Error(
+        await config.errors.connectionAlreadyInRoom(connection, room),
+      );
+    }
+
+    if (!connection.rooms.includes(room)) {
+      const found = await chatRoom.exists(room);
+      if (!found) {
+        throw new Error(await config.errors.connectionRoomNotExist(room));
+      }
+
+      await api.chatRoom.runMiddleware(connection, room, "join");
+
+      if (!connection.rooms.includes(room)) {
+        connection.rooms.push(room);
+      }
+
+      const memberDetails = await chatRoom.generateMemberDetails(connection);
+      await client().hset(
+        api.chatRoom.keys.members + room,
+        connection.id,
+        JSON.stringify(memberDetails),
+      );
+    }
+
+    return true;
+  }
+
+  /**
+   * Remote a connection (via id) from a room.  Throws errors if the room does not exist, or the connection is not in the room.  Middleware errors also throw.
+   * toWaitRemote: Should this method wait until the remote Actionhero server (the one the connection is connected too) responds?
+   */
+  export async function removeMember(
+    connectionId: string,
+    room: string,
+    toWaitRemote: boolean = true,
+  ): Promise<any> {
+    const connection = api.connections.connections[connectionId];
+    if (!connection) {
+      return redis.doCluster(
+        "api.chatRoom.removeMember",
+        [connectionId, room],
+        connectionId,
+        toWaitRemote,
+      );
+    }
+
+    if (!connection.rooms.includes(room)) {
+      throw new Error(
+        await config.errors.connectionNotInRoom(connection, room),
+      );
+    }
+
+    if (connection.rooms.includes(room)) {
+      const found = await chatRoom.exists(room);
+      if (!found) {
+        throw new Error(await config.errors.connectionRoomNotExist(room));
+      }
+
+      await api.chatRoom.runMiddleware(connection, room, "leave");
+
+      if (connection.rooms.includes(room)) {
+        const index = connection.rooms.indexOf(room);
+        connection.rooms.splice(index, 1);
+      }
+
+      await client().hdel(api.chatRoom.keys.members + room, connection.id);
+    }
+
+    return true;
+  }
+
+  /**
+   * Send a message to all clients connected to this room
+   * - connection:
+   *        - {} send to every connections
+   *        - should either be a real client you are emulating (found in api.connections)
+   *        - a mock
+   * - room is the string name of an already-existing room
+   * - message can be anything: string, json, object, etc
+   */
+  export async function broadcast(
+    connection: Partial<Connection>,
+    room: string,
+    message: any,
+  ) {
+    return api.chatRoom.broadcast(connection, room, message);
+  }
+}

package/src/modules/config.ts

@@ -0,0 +1,246 @@
+import * as fs from "fs";
+import * as path from "path";
+import { utils } from "./utils";
+import { ensureNoTsHeaderOrSpecFiles } from "./utils/ensureNoTsHeaderOrSpecFiles";
+
+import { env, recalculateEnv } from "./../classes/process/env";
+import { id, recalcuateId } from "./../classes/process/id";
+import {
+  actionheroVersion,
+  recalculateActionheroVersion,
+} from "./../classes/process/actionheroVersion";
+import {
+  recalculateIsTypescript,
+  typescript,
+} from "./../classes/process/typescript";
+import {
+  projectRoot,
+  recalculateProjectRoot,
+} from "./../classes/process/projectRoot";
+import { RouteMethod, RoutesConfig, RouteType } from "..";
+import { ActionheroConfigInterface } from "../classes/config";
+import { safeGlobSync } from "./utils/safeGlob";
+
+export function buildConfig() {
+  const configPaths: string[] = [];
+
+  let config: Partial<ActionheroConfigInterface> = {
+    process: {
+      env,
+      id,
+      typescript,
+      projectRoot,
+      actionheroVersion,
+    },
+  };
+
+  // We support multiple configuration paths as follows:
+  //
+  // 1. Use the project 'config' folder, if it exists.
+  // 2. "actionhero --config=PATH1 --config=PATH2 --config=PATH3,PATH4"
+  // 3. "ACTIONHERO_CONFIG=PATH1,PATH2 npm start"
+  // 4. "ACTIONHERO_CONFIG_OVERRIDES" (stringified JSON) can partially override any of the config objects loaded from the above
+  //
+  // Note that if --config or ACTIONHERO_CONFIG are used, they _overwrite_ the use of the default "config" folder. If
+  // you wish to use both, you need to re-specify "config", e.g. "--config=config,local-config". Also, note that
+  // specifying multiple --config options on the command line does exactly the same thing as using one parameter with
+  // comma separators, however the environment variable method only supports the comma-delimited syntax.
+
+  function addConfigPath(
+    pathToCheck: string | Array<string>,
+    alreadySplit: boolean,
+  ) {
+    if (typeof pathToCheck === "string") {
+      if (!alreadySplit) {
+        addConfigPath(pathToCheck.split(","), true);
+      } else {
+        if (pathToCheck.charAt(0) !== "/") {
+          pathToCheck = path.resolve(projectRoot, pathToCheck);
+        }
+        if (fs.existsSync(pathToCheck)) {
+          configPaths.push(pathToCheck);
+        }
+      }
+    } else if (Array.isArray(pathToCheck)) {
+      pathToCheck.map((entry) => {
+        addConfigPath(entry, alreadySplit);
+      });
+    }
+  }
+
+  [utils.argv.config?.toString(), process.env.ACTIONHERO_CONFIG].map(
+    (entry) => {
+      addConfigPath(entry, false);
+    },
+  );
+
+  if (configPaths.length < 1 && typescript) {
+    addConfigPath("src/config", false);
+  }
+
+  if (configPaths.length < 1) {
+    addConfigPath("dist/config", false);
+  }
+
+  if (configPaths.length < 1) {
+    throw new Error(
+      configPaths +
+        "No config directory found in this project.  Did you compile your typescript project?",
+    );
+  }
+
+  const loadConfigFile = (f: string) => {
+    const localConfig = require(f);
+    if (f.includes("routes.js") || f.includes("routes.ts")) {
+      // We don't want to merge in routes from Actionhero core unless we are running core directly
+      // Routes can be loaded by plugins via `registerRoute`
+      if (
+        f.includes(`${path.sep}node_modules${path.sep}actionhero${path.sep}`)
+      ) {
+        return;
+      }
+
+      let localRoutes: { routes: Partial<RoutesConfig> } = { routes: {} };
+
+      if (localConfig.DEFAULT) {
+        // @ts-ignore
+        localRoutes = utils.hashMerge(localRoutes, localConfig.DEFAULT, config);
+      }
+
+      if (localConfig[env]) {
+        // @ts-ignore
+        localRoutes = utils.hashMerge(localRoutes, localConfig[env], config);
+      }
+
+      (Object.keys(localRoutes.routes) as RouteMethod[]).forEach((v) => {
+        if (config.routes && config.routes[v]) {
+          config.routes[v].push(...localRoutes.routes[v]);
+        } else {
+          if (!config.routes) config.routes = {};
+          config.routes[v] = localRoutes.routes[v];
+        }
+      });
+    } else {
+      if (localConfig.DEFAULT) {
+        config = utils.hashMerge(config, localConfig.DEFAULT, config);
+      }
+
+      if (localConfig[env]) {
+        config = utils.hashMerge(config, localConfig[env], config);
+      }
+    }
+  };
+
+  const loadConfigDirectory = (configPath: string, watch: boolean) => {
+    const configFiles = ensureNoTsHeaderOrSpecFiles(
+      safeGlobSync(path.join(configPath, "**", "**/*(*.js|*.ts)")),
+    );
+
+    let loadRetries = 0;
+    let loadErrors: Record<
+      string,
+      { error: NodeJS.ErrnoException; msg: string }
+    > = {};
+    for (let i = 0, limit = configFiles.length; i < limit; i++) {
+      const f = configFiles[i];
+      try {
+        // attempt configuration file load
+        loadConfigFile(f);
+
+        // configuration file load success: clear retries and
+        // errors since progress has been made
+        loadRetries = 0;
+        loadErrors = {};
+      } catch (error) {
+        // error loading configuration, abort if all remaining
+        // configuration files have been tried and failed
+        // indicating inability to progress
+        loadErrors[f] = { error: error, msg: error.toString() };
+        if (++loadRetries === limit - i) {
+          Object.keys(loadErrors).forEach((e) => {
+            console.log(loadErrors[e].error.stack);
+            console.log("");
+            delete loadErrors[e].error;
+          });
+
+          throw new Error(
+            "Unable to load configurations, errors: " +
+              JSON.stringify(loadErrors),
+          );
+        }
+        // adjust configuration files list: remove and push
+        // failed configuration to the end of the list and
+        // continue with next file at same index
+        configFiles.push(configFiles.splice(i--, 1)[0]);
+        continue;
+      }
+    }
+
+    // We load the config twice. Utilize configuration files load order that succeeded on the first pass.
+    // This is to allow 'literal' values to be loaded whenever possible, and then for references to be resolved
+    configFiles.forEach(loadConfigFile);
+
+    // Remove duplicate routes since we might be loading from multiple config directories, also we load every
+    // config directory twice.
+    if (config.routes) {
+      (Object.keys(config.routes) as RouteMethod[]).forEach((v) => {
+        config.routes[v] = config.routes[v].filter(
+          (route: RouteType, index: number, self: RouteType[]) =>
+            index ===
+            self.findIndex(
+              (r) =>
+                r.path === route.path &&
+                r.action === route.action &&
+                r.apiVersion === route.apiVersion &&
+                r.matchTrailingPathParts === route.matchTrailingPathParts &&
+                r.dir === route.dir,
+            ),
+        );
+      });
+    }
+  };
+
+  // load the default config of actionhero
+  loadConfigDirectory(path.join(__dirname, "/../config"), false);
+
+  // load the project specific config
+  configPaths.map((p) => loadConfigDirectory(p, false));
+
+  if (process.env.ACTIONHERO_CONFIG_OVERRIDES) {
+    try {
+      config = utils.hashMerge(
+        config,
+        JSON.parse(process.env.ACTIONHERO_CONFIG_OVERRIDES),
+      );
+    } catch (error) {
+      throw new Error(`could not parse ACTIONHERO_CONFIG_OVERRIDES: ${error}`);
+    }
+  }
+
+  if (utils.argv.ACTIONHERO_CONFIG_OVERRIDES) {
+    try {
+      config = utils.hashMerge(
+        config,
+        JSON.parse(utils.argv.ACTIONHERO_CONFIG_OVERRIDES.toString()),
+      );
+    } catch (error) {
+      throw new Error(`could not parse ACTIONHERO_CONFIG_OVERRIDES: ${error}`);
+    }
+  }
+
+  return config;
+}
+
+export let config = buildConfig();
+
+/**
+ * Rebuild Actionhero's `config` object.  Useful when Environment variables effecting the config may have changed.
+ */
+export const rebuildConfig = () => {
+  recalculateEnv();
+  recalculateActionheroVersion();
+  recalcuateId();
+  recalculateProjectRoot();
+  recalculateIsTypescript();
+  config = buildConfig();
+};

package/src/modules/log.ts

@@ -0,0 +1,62 @@
+import * as winston from "winston";
+import { config } from "./config";
+import { utils } from "./utils";
+
+// exported as `import { loggers } from "actionhero"`
+export let loggers: winston.Logger[] = [];
+
+config.general.paths.log.forEach((p: string) => {
+  try {
+    utils.fileUtils.createDirSafely(p);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+});
+
+loggers = config.logger.loggers.map((loggerBuilder: Function) => {
+  const resolvedLogger = loggerBuilder(config);
+  return winston.createLogger(resolvedLogger);
+});
+
+export type ActionheroLogLevel =
+  | "emerg"
+  | "alert"
+  | "crit"
+  | "error"
+  | "warning"
+  | "notice"
+  | "info"
+  | "debug";
+
+/**
+ * Log a message, with optional metadata.  The message can be logged to a number of locations (stdio, files, etc) as configured via config/logger.js
+ *
+ * The most basic use.  Will assume 'info' as the severity: `log('hello')`
+ * Custom severity: `log('OH NO!', 'warning')`
+ * Custom severity with a metadata object: `log('OH NO, something went wrong', 'warning', { error: new Error('things are busted') })`
+ *
+ * The default log levels are: `emerg: 0, alert: 1, crit: 2,  error: 3,  warning: 4,  notice: 5, info: 6, debug: 7`.
+ * Logging levels in winston conform to the severity ordering specified by RFC5424: severity of all levels is assumed to be numerically ascending from most important to least important.
+ * Learn more at https://github.com/winstonjs/winston
+ */
+export function log(
+  message: string,
+  severity: ActionheroLogLevel = "info",
+  data?: any,
+) {
+  loggers.map((logger) => {
+    if (logger.levels[severity] === undefined) {
+      severity = "info";
+    }
+
+    const args = [severity, message];
+
+    if (data !== null && data !== undefined) {
+      args.push(data);
+    }
+
+    return logger.log.apply(logger, args);
+  });
+}