0z2i6v3u5t 1.0.0

package/src/initializers/actions.ts

@@ -0,0 +1,125 @@
+import * as path from "path";
+import { api, config, log, utils, Initializer, Action } from "../index";
+import { safeGlobSync } from "../modules/utils/safeGlob";
+import * as ActionModule from "./../modules/action";
+
+export interface ActionsApi {
+  actions: {
+    [key: string]: {
+      [key: string]: Action;
+    };
+  };
+  versions: {
+    [key: string]: Array<string | number>;
+  };
+  middleware: {
+    [key: string]: ActionModule.action.ActionMiddleware;
+  };
+  globalMiddleware: Array<string>;
+  loadFile?: Function;
+}
+
+export class ActionsInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "actions";
+    this.loadPriority = 410;
+  }
+
+  async initialize() {
+    api.actions = {
+      actions: {},
+      versions: {},
+      middleware: {},
+      globalMiddleware: [],
+    };
+
+    api.actions.loadFile = async (
+      fullFilePath: string,
+      reload: boolean = false,
+    ) => {
+      const loadMessage = (action: Action) => {
+        if (reload) {
+          log(
+            `action reloaded: ${action.name} @ v${action.version}, ${fullFilePath}`,
+            "info",
+          );
+        } else {
+          log(
+            `action loaded: ${action.name} @ v${action.version}, ${fullFilePath}`,
+            "debug",
+          );
+        }
+      };
+
+      let action;
+
+      try {
+        let collection = await import(fullFilePath);
+        if (typeof collection === "function") {
+          collection = [collection];
+        }
+        for (const i in collection) {
+          action = new collection[i]();
+          await action.validate(api);
+          if (!api.actions.actions[action.name]) {
+            api.actions.actions[action.name] = {};
+          }
+
+          if (!api.actions.versions[action.name]) {
+            api.actions.versions[action.name] = [];
+          }
+
+          if (api.actions.actions[action.name][action.version] && !reload) {
+            log(
+              `an existing action with the same name \`${action.name}\` will be overridden by the file ${fullFilePath}`,
+              "warning",
+            );
+          }
+
+          api.actions.actions[action.name][action.version] = action;
+          api.actions.versions[action.name].push(action.version);
+          api.actions.versions[action.name].sort();
+          loadMessage(action);
+        }
+      } catch (error) {
+        try {
+          api.exceptionHandlers.initializer(error, fullFilePath);
+          delete api.actions.actions[action.name][action.version];
+        } catch (_error) {
+          throw error;
+        }
+      }
+    };
+
+    for (const p of config.general.paths.action) {
+      let files = safeGlobSync(path.join(p, "**", "**/*(*.js|*.ts)"));
+      files = utils.ensureNoTsHeaderOrSpecFiles(files);
+      for (const j in files) {
+        await api.actions.loadFile(files[j]);
+      }
+    }
+
+    for (const plugin of Object.values(config.plugins)) {
+      if (plugin.actions !== false) {
+        const pluginPath: string = path.normalize(plugin.path);
+
+        // old style at the root of the project
+        let files = safeGlobSync(
+          path.join(pluginPath, "actions", "**", "*.js"),
+        );
+
+        files = files.concat(
+          safeGlobSync(path.join(pluginPath, "dist", "actions", "**", "*.js")),
+        );
+
+        utils
+          .ensureNoTsHeaderOrSpecFiles(files)
+          .forEach((f) => api.actions.loadFile(f));
+      }
+    }
+
+    // now that the actions are loaded, we can add all the inputs to api.params
+    api.params.buildPostVariables();
+  }
+}

package/src/initializers/chatRoom.ts

@@ -0,0 +1,214 @@
+import { api, config, id, log, chatRoom, redis, Initializer } from "../index";
+import { Connection } from "../classes/connection";
+import * as ChatModule from "./../modules/chatRoom";
+
+export interface ChatRoomApi {
+  middleware: {
+    [key: string]: ChatModule.chatRoom.ChatMiddleware;
+  };
+  globalMiddleware: Array<string>;
+  keys: { [keys: string]: string };
+  messageChannel: string;
+  broadcast: ChatRoomInitializer["broadcast"];
+  generateMessagePayload: ChatRoomInitializer["generateMessagePayload"];
+  incomingMessage: ChatRoomInitializer["incomingMessage"];
+  incomingMessagePerConnection?: ChatRoomInitializer["incomingMessagePerConnection"];
+  runMiddleware: ChatRoomInitializer["runMiddleware"];
+  removeMember: ChatRoomInitializer["removeMember"];
+}
+
+export type ChatMiddlewareDirections =
+  | "join"
+  | "leave"
+  | "onSayReceive"
+  | "say";
+
+export type MessagePayloadType = ReturnType<
+  typeof api.chatRoom.generateMessagePayload
+>;
+
+/**
+ * Chat & Realtime Communication Methods
+ */
+export class ChatRoomInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "chatRoom";
+    this.loadPriority = 520;
+    this.startPriority = 200;
+  }
+
+  broadcast = async (
+    connection: Partial<Connection>,
+    room: string,
+    message: object | Array<any> | string,
+  ) => {
+    if (!connection) connection = {};
+
+    if (!room || !message) {
+      throw new Error(
+        config.errors.connectionRoomAndMessage(connection as Connection),
+      );
+    } else if (
+      connection.rooms === undefined ||
+      connection.rooms.indexOf(room) > -1
+    ) {
+      const payload: ChatModule.chatRoom.ChatPubSubMessage = {
+        messageType: "chat",
+        serverToken: config.general.serverToken,
+        serverId: id,
+        message: message,
+        sentAt: new Date().getTime(),
+        connection: {
+          id: connection.id || "0",
+          room: room,
+        },
+      };
+
+      const messagePayload = api.chatRoom.generateMessagePayload(payload);
+      const newPayload = await api.chatRoom.runMiddleware(
+        connection,
+        messagePayload.room,
+        "onSayReceive",
+        messagePayload,
+      );
+
+      if (newPayload !== null && newPayload !== undefined) {
+        const payloadToSend: ChatModule.chatRoom.ChatPubSubMessage = {
+          messageType: "chat",
+          serverToken: config.general.serverToken,
+          serverId: id,
+          message: newPayload.message,
+          sentAt: newPayload.sentAt,
+          connection: {
+            id: newPayload.from,
+            room: newPayload.room,
+          },
+        };
+
+        await redis.publish(payloadToSend);
+      }
+    } else {
+      throw new Error(
+        config.errors.connectionNotInRoom(connection as Connection, room),
+      );
+    }
+  };
+
+  generateMessagePayload = (message: chatRoom.ChatPubSubMessage) => {
+    return {
+      message: message.message,
+      room: message.connection.room,
+      from: message.connection.id,
+      context: "user",
+      sentAt: message.sentAt,
+    } as Record<string, any>; // we want to relax the return type to a Record so that this method can be modified by users
+  };
+
+  incomingMessage = (message: ChatModule.chatRoom.ChatPubSubMessage) => {
+    const messagePayload = api.chatRoom.generateMessagePayload(message);
+    Object.keys(api.connections.connections).forEach((connectionId) => {
+      const connection = api.connections.connections[connectionId];
+      // we can parallelize this, no need to await
+      api.chatRoom.incomingMessagePerConnection(connection, messagePayload);
+    });
+  };
+
+  incomingMessagePerConnection = async (
+    connection: Connection,
+    messagePayload: MessagePayloadType,
+  ) => {
+    if (
+      connection.canChat === true &&
+      connection.rooms.indexOf(messagePayload.room) > -1
+    ) {
+      try {
+        const newMessagePayload = await api.chatRoom.runMiddleware(
+          connection,
+          messagePayload.room,
+          "say",
+          messagePayload,
+        );
+        if (newMessagePayload !== null) {
+          connection.sendMessage(newMessagePayload, "say");
+        }
+      } catch (error) {
+        log(error, "warning", { messagePayload, connection });
+      }
+    }
+  };
+
+  runMiddleware = async (
+    connection: Partial<Connection>,
+    room: string,
+    direction: ChatMiddlewareDirections,
+    messagePayload?: MessagePayloadType,
+  ) => {
+    let newMessagePayload: MessagePayloadType;
+    if (messagePayload) newMessagePayload = Object.assign({}, messagePayload);
+
+    for (const name of api.chatRoom.globalMiddleware) {
+      const m = api.chatRoom.middleware[name];
+      if (typeof m[direction] === "function") {
+        if (messagePayload) {
+          newMessagePayload =
+            (await m[direction](connection, room, newMessagePayload)) ?? null;
+        } else {
+          await m[direction](connection, room);
+        }
+      }
+    }
+    return newMessagePayload;
+  };
+
+  removeMember = (
+    connectionId: string,
+    room: string,
+    toWaitRemote: boolean = true,
+  ) => chatRoom.removeMember(connectionId, room, toWaitRemote);
+
+  async initialize() {
+    api.chatRoom = {
+      middleware: {},
+      globalMiddleware: [],
+      messageChannel: "/actionhero/chat/chat",
+      keys: {
+        rooms: "actionhero:chatRoom:rooms",
+        members: "actionhero:chatRoom:members:",
+      },
+      broadcast: this.broadcast,
+      generateMessagePayload: this.generateMessagePayload,
+      incomingMessage: this.incomingMessage,
+      incomingMessagePerConnection: this.incomingMessagePerConnection,
+      runMiddleware: this.runMiddleware,
+      removeMember: this.removeMember,
+    };
+  }
+
+  async start() {
+    api.redis.subscriptionHandlers.chat = (
+      message: ChatModule.chatRoom.ChatPubSubMessage,
+    ) => {
+      if (api.chatRoom) {
+        api.chatRoom.incomingMessage(message);
+      }
+    };
+
+    for (const [room, options] of Object.entries(
+      config.general.startingChatRooms,
+    )) {
+      log(`ensuring the existence of the chatRoom: ${room}`, "debug");
+      try {
+        await chatRoom.add(room);
+      } catch (error) {
+        if (
+          !error
+            .toString()
+            .match(await config.errors.connectionRoomExists(room))
+        ) {
+          throw error;
+        }
+      }
+    }
+  }
+}

package/src/initializers/connections.ts

@@ -0,0 +1,124 @@
+import { api, config, redis, Initializer, Connection } from "../index";
+
+/**
+ * ```js
+ *var connectionMiddleware = {
+ *name: 'connection middleware',
+ *priority: 1000,
+ *create: (connection) => {
+ *  // do stuff
+ *},
+ *destroy:(connection) => {
+ *  // do stuff
+ *}
+ *}
+ * ```
+ */
+export interface ConnectionMiddleware {
+  /**Unique name for the middleware. */
+  name: string;
+  /**Module load order. Defaults to `api.config.general.defaultMiddlewarePriority`. */
+  priority?: number;
+  /**Called for each new connection when it is created. Connection is passed to the event handler*/
+  create?: Function;
+  /**Called for each connection before it is destroyed. Connection is passed to the event handler*/
+  destroy?: Function;
+}
+
+export interface ConnectionsApi {
+  connections: {
+    [key: string]: Connection;
+  };
+  middleware: {
+    [key: string]: ConnectionMiddleware;
+  };
+  globalMiddleware: Array<string>;
+  apply: ConnectionsInitializer["apply"];
+  applyResponder: ConnectionsInitializer["applyResponder"];
+  addMiddleware: ConnectionsInitializer["addMiddleware"];
+  cleanConnection: ConnectionsInitializer["cleanConnection"];
+}
+
+export class ConnectionsInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "connections";
+    this.loadPriority = 400;
+  }
+
+  apply = async (
+    connectionId: string,
+    method?: string,
+    args?: any[] | Record<string, any>,
+  ) => {
+    return redis.doCluster<Connection>(
+      "api.connections.applyResponder",
+      [connectionId, method, args],
+      connectionId,
+      true,
+    );
+  };
+
+  applyResponder = async (
+    connectionId: string,
+    method: keyof InstanceType<typeof Connection>,
+    args: any,
+  ) => {
+    const connection = api.connections.connections[connectionId];
+    if (!connection) return;
+
+    if (method && args) {
+      if (method === "sendMessage" || method === "sendFile") {
+        await connection[method](args);
+      } else {
+        //@ts-ignore
+        await connection[method].apply(connection, args);
+      }
+    }
+    return api.connections.cleanConnection(connection);
+  };
+
+  addMiddleware = (data: ConnectionMiddleware) => {
+    if (!data.name) {
+      throw new Error("middleware.name is required");
+    }
+    if (!data.priority) {
+      data.priority = config.general.defaultMiddlewarePriority;
+    }
+    data.priority = Number(data.priority);
+    api.connections.middleware[data.name] = data;
+
+    api.connections.globalMiddleware.push(data.name);
+    api.connections.globalMiddleware.sort(
+      (a, b) =>
+        api.connections.middleware[a].priority -
+        api.connections.middleware[b].priority,
+    );
+  };
+
+  cleanConnection = (connection: Connection) => {
+    const clean: { [key: string]: any } = {};
+    for (const [key, value] of Object.entries(connection)) {
+      if (key !== "rawConnection" && key !== "api") {
+        try {
+          JSON.stringify(value);
+          clean[key] = value;
+        } catch (error) {}
+      }
+    }
+
+    return clean;
+  };
+
+  async initialize() {
+    api.connections = {
+      connections: {},
+      middleware: {},
+      globalMiddleware: [],
+      apply: this.apply,
+      applyResponder: this.applyResponder,
+      addMiddleware: this.addMiddleware,
+      cleanConnection: this.cleanConnection,
+    };
+  }
+}

package/src/initializers/exceptions.ts

@@ -0,0 +1,155 @@
+import { api, config, log, Initializer, Action } from "../index";
+import { ExceptionReporter } from "../classes/exceptionReporter";
+import { ParsedJob } from "node-resque";
+import { ActionheroLogLevel } from "../modules/log";
+
+export interface ExceptionHandlerAPI {
+  reporters: Array<ExceptionReporter>;
+  report: ExceptionsInitializer["report"];
+  initializer: ExceptionsInitializer["initializer"];
+  action: ExceptionsInitializer["action"];
+  task: ExceptionsInitializer["task"];
+}
+
+/**
+ * Handlers for when things go wrong.
+ */
+export class ExceptionsInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "exceptions";
+    this.loadPriority = 1;
+  }
+
+  report = (
+    error: NodeJS.ErrnoException,
+    type: string,
+    name: string,
+    objects?: any,
+    severity?: ActionheroLogLevel,
+  ) => {
+    if (!severity) severity = "error";
+
+    for (const reporter of api.exceptionHandlers.reporters) {
+      reporter(error, type, name, objects, severity);
+    }
+  };
+
+  initializer = (error: NodeJS.ErrnoException, fullFilePath: string) => {
+    const name = "initializer:" + fullFilePath;
+    api.exceptionHandlers.report(
+      error,
+      "initializer",
+      name,
+      { fullFilePath: fullFilePath },
+      "alert",
+    );
+  };
+
+  action = (
+    error: NodeJS.ErrnoException,
+    {
+      to,
+      action,
+      params,
+      duration,
+      response,
+    }: {
+      to: string;
+      action: Action["name"];
+      params: string;
+      duration: number;
+      response: string;
+    },
+  ) => {
+    api.exceptionHandlers.report(
+      error,
+      "action",
+      `action: ${action}`,
+      { to, action, params, duration, error, response },
+      "alert",
+    );
+  };
+
+  task = (
+    error: NodeJS.ErrnoException,
+    queue: string,
+    task: ParsedJob,
+    workerId: string | number,
+  ) => {
+    let simpleName;
+    try {
+      simpleName = task["class"];
+    } catch (e) {
+      simpleName = error.message;
+    }
+    const name = "task:" + simpleName;
+    api.exceptionHandlers.report(
+      error,
+      "task",
+      name,
+      { task: task, queue: queue, workerId: workerId },
+      config.tasks.workerLogging.failure,
+    );
+  };
+
+  async initialize() {
+    api.exceptionHandlers = {
+      reporters: [],
+      report: this.report,
+      initializer: this.initializer,
+      action: this.action,
+      task: this.task,
+    };
+
+    api.exceptionHandlers.reporters.push(consoleReporter);
+  }
+}
+
+const consoleReporter: ExceptionReporter = (
+  error: NodeJS.ErrnoException & { [key: string]: any },
+  type,
+  name,
+  objects,
+  severity,
+) => {
+  let message = "";
+  const data = error["data"] ?? {};
+
+  if (type === "uncaught") {
+    message = `Uncaught ${name}`;
+  } else if (type === "action") {
+    // no need to log anything, it was handled already by the actionProcessor
+  } else if (type === "initializer") {
+    message = `Error from Initializer`;
+  } else if (type === "task") {
+    message = `Error from Task`;
+    data["name"] = name;
+    data["queue"] = objects.queue;
+    data["worker"] = objects.workerId;
+    data["arguments"] = objects?.task?.args
+      ? JSON.stringify(objects.task.args[0])
+      : undefined;
+  } else {
+    message = `Error: ${error?.message || error.toString()}`;
+    Object.getOwnPropertyNames(error)
+      .filter((prop) => prop !== "message")
+      .sort((a, b) => (a === "stack" || b === "stack" ? -1 : 1))
+      .forEach((prop) => (data[prop] = error[prop]));
+    data["type"] = type;
+    data["name"] = name;
+    data["data"] = objects;
+  }
+
+  if (error["stack"]) {
+    data["stack"] = error.stack;
+  } else {
+    data["stack"] = error.message ?? error.toString();
+  }
+
+  try {
+    if (message) log(message, severity, data);
+  } catch (e) {
+    console.log(message, data);
+  }
+};

package/src/initializers/params.ts

@@ -0,0 +1,52 @@
+import { api, utils, Initializer } from "../index";
+
+export interface ParamsApi {
+  globalSafeParams?: Array<string>;
+  postVariables: Array<string>;
+  buildPostVariables: ParamsInitializer["buildPostVariables"];
+}
+
+/**
+ * Collects and formats allowed params for this server.
+ */
+export class ParamsInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "params";
+    this.loadPriority = 400;
+  }
+
+  buildPostVariables = () => {
+    const postVariables = [];
+    let i: string;
+    let j: string | number;
+
+    api.params.globalSafeParams.forEach((p) => {
+      postVariables.push(p);
+    });
+
+    for (i in api.actions.actions) {
+      for (j in api.actions.actions[i]) {
+        const action = api.actions.actions[i][j];
+        for (const key in action.inputs) postVariables.push(key);
+      }
+    }
+
+    api.params.postVariables = utils.arrayUnique(postVariables);
+    return api.params.postVariables;
+  };
+
+  async initialize() {
+    api.params = {
+      postVariables: [],
+      buildPostVariables: this.buildPostVariables,
+      globalSafeParams: [
+        "file",
+        "apiVersion",
+        "callback",
+        "action",
+        "messageId",
+      ],
+    };
+  }
+}