0z2i6v3u5t 1.0.0

package/src/modules/redis.ts

@@ -0,0 +1,93 @@
+import * as uuid from "uuid";
+import { config, api, id, log } from "./../index";
+
+export namespace redis {
+  export interface PubSubMessage {
+    [key: string]: any;
+  }
+
+  /**
+   * Publish a message to all other Actionhero nodes in the cluster.  Will be authenticated against `api.config.serverToken`
+   * ```js
+   * let payload = {
+   *   messageType: 'myMessageType',
+   *   serverId: api.id,
+   *   serverToken: api.config.general.serverToken,
+   *   message: 'hello!'
+   * }
+   *
+   * await api.redis.publish(payload)
+   * ```
+   */
+  export async function publish(payload: object | Array<any>) {
+    const channel = config.general.channel;
+    const connection = api.redis.clients.client;
+    const stringPayload = JSON.stringify(payload);
+    if (connection.status !== "close" && connection.status !== "end") {
+      return connection.publish(channel, stringPayload);
+    } else {
+      log(`cannot send message, redis disconnected`, "error", {
+        channel,
+        payload,
+      });
+    }
+  }
+
+  /**
+   * Invoke a command on all servers in this cluster.
+   */
+  export async function doCluster<T>(
+    method: string,
+    args: Array<any> = [],
+    connectionId?: string,
+    waitForResponse: boolean = false,
+  ): Promise<T extends any ? T : unknown> {
+    const messageId = uuid.v4();
+    const payload = {
+      messageType: "do",
+      serverId: id,
+      serverToken: config.general.serverToken,
+      messageId: messageId,
+      method: method,
+      connectionId: connectionId,
+      args: args, // [1,2,3]
+    };
+
+    // we need to be sure that we build the response-handling promise before sending the request to Redis
+    // it is possible for another node to get and work the request before we resolve our write
+    // see https://github.com/actionhero/actionhero/issues/1244 for more information
+    if (waitForResponse) {
+      return new Promise(async (resolve, reject) => {
+        const timer = setTimeout(
+          () => reject(new Error("RPC Timeout")),
+          config.general.rpcTimeout,
+        );
+        api.redis.rpcCallbacks[messageId] = { timer, resolve, reject };
+        try {
+          await redis.publish(payload);
+        } catch (e) {
+          clearTimeout(timer);
+          delete api.redis.rpcCallbacks[messageId];
+          throw e;
+        }
+      });
+    } else {
+      return redis.publish(payload) as T extends any ? T : unknown;
+    }
+  }
+
+  export async function respondCluster(
+    messageId: string,
+    response: PubSubMessage,
+  ) {
+    const payload = {
+      messageType: "doResponse",
+      serverId: id,
+      serverToken: config.general.serverToken,
+      messageId: messageId,
+      response: response, // args to pass back, including error
+    };
+
+    await redis.publish(payload);
+  }
+}

package/src/modules/route.ts

@@ -0,0 +1,59 @@
+import { api } from "./../index";
+
+export const routerMethods = [
+  "all",
+  "head",
+  "get",
+  "patch",
+  "post",
+  "put",
+  "delete",
+] as const;
+export type RouteMethod = (typeof routerMethods)[number];
+
+export type RouteType = {
+  path: string;
+  action: string;
+  dir?: string;
+  matchTrailingPathParts?: boolean;
+  apiVersion?: number | string;
+};
+
+export type RoutesConfig = Partial<
+  Record<(typeof routerMethods)[number], RouteType[]>
+>;
+
+export namespace route {
+  /**
+   * Programmatically define a route, rather than using `config.routes`.  This is useful for plugins which may define routes as well.
+   * You can use both `routes.registerRoute` and `config.routes` in the same project.
+   *
+   * * method:                 HTTP verb (get, put, etc)
+   * * path:                   The route in question.  Can use variables.
+   * * action:                 The action to call with this route.
+   * * apiVersion:             The version of the action to call, if more than one.
+   * * matchTrailingPathParts: Allows the final segment of your route to absorb all trailing path parts in a matched variable. (ie: /api/user would match /api/user/123)
+   * * dir:                    Which folder to serve static files from (must by included in config.general.paths)
+   */
+  export function registerRoute(
+    method: string,
+    path: string,
+    action: string,
+    apiVersion?: number | string,
+    matchTrailingPathParts: boolean = false,
+    dir?: string,
+  ) {
+    const verbs =
+      method === "all" ? routerMethods : ([method] as [RouteMethod]);
+    for (const vi in verbs) {
+      const verb = verbs[vi];
+      api.routes.routes[verb].push({
+        path: path,
+        matchTrailingPathParts: matchTrailingPathParts,
+        action: action,
+        dir: dir,
+        apiVersion: apiVersion,
+      });
+    }
+  }
+}

package/src/modules/specHelper.ts

@@ -0,0 +1,182 @@
+import * as uuid from "uuid";
+import { Worker } from "node-resque";
+import { api, config, task, Task, Action, Connection } from "./../index";
+import { WebServer } from "../servers/web";
+import { AsyncReturnType } from "type-fest";
+import { TaskInputs } from "../classes/task";
+
+export type SpecHelperConnection = Connection & {
+  actionCallbacks?: { [key: string]: Function };
+};
+
+export namespace specHelper {
+  /**
+   * Generate a connection to use in your tests
+   */
+  export async function buildConnection() {
+    return api.specHelper.Connection.createAsync() as SpecHelperConnection;
+  }
+
+  /**
+   * Run an action via the specHelper server.
+   */
+  export async function runAction<A extends Action | void = void>(
+    actionName: string,
+    input: Partial<SpecHelperConnection> | Record<string, any> = {},
+  ) {
+    let connection: SpecHelperConnection;
+
+    if (input.id && input.type === "testServer") {
+      connection = input as SpecHelperConnection;
+    } else {
+      connection = await specHelper.buildConnection();
+      connection.params = input;
+    }
+
+    connection.params.action = actionName;
+    connection.messageId = connection.params.messageId || uuid.v4();
+
+    const response: (A extends Action
+      ? AsyncReturnType<A["run"]>
+      : { [key: string]: any }) & {
+      messageId?: string;
+      error?: NodeJS.ErrnoException | string | any;
+      requesterInformation?: ReturnType<WebServer["buildRequesterInformation"]>;
+      serverInformation?: ReturnType<WebServer["buildServerInformation"]>;
+    } = await new Promise((resolve) => {
+      api.servers.servers.testServer.processAction(connection);
+      connection.actionCallbacks[connection.messageId] = resolve;
+    });
+
+    return response;
+  }
+
+  /**
+   * Mock a specHelper connection requesting a file from the server.
+   */
+  export async function getStaticFile(file: string): Promise<any> {
+    const connection = await specHelper.buildConnection();
+    connection.params.file = file;
+
+    const response = await new Promise((resolve) => {
+      api.servers.servers.testServer.processFile(connection);
+      connection.actionCallbacks[connection.messageId] = resolve;
+    });
+
+    return response;
+  }
+
+  /**
+   * Use the specHelper to run a task.
+   * Note: this only runs the task's `run()` method, and no middleware.  This is faster than api.specHelper.runFullTask.
+   */
+  export async function runTask<T extends Task | void = void>(
+    taskName: string,
+    params: object | Array<any>,
+  ) {
+    if (!api.tasks.tasks[taskName]) {
+      throw new Error(`task ${taskName} not found`);
+    }
+
+    const result: (T extends Task
+      ? AsyncReturnType<T["run"]>
+      : { [key: string]: any }) & {
+      error?: NodeJS.ErrnoException | string;
+    } = await api.tasks.tasks[taskName].run(params, undefined);
+    return result;
+  }
+
+  /**
+   * Use the specHelper to run a task.
+   * Note: this will run a full Task worker, and will also include any middleware.  This is slower than api.specHelper.runTask.
+   */
+  export async function runFullTask<T extends Task | void = void>(
+    taskName: string,
+    params: object | Array<any>,
+  ) {
+    const worker = new Worker(
+      {
+        connection: {
+          redis: api.redis.clients.tasks,
+          pkg:
+            api.redis.clients.tasks?.constructor?.name === "RedisMock"
+              ? "ioredis-mock"
+              : "ioredis",
+        },
+        queues: (Array.isArray(config.tasks.queues)
+          ? config.tasks.queues
+          : await config.tasks.queues()) || ["default"],
+      },
+      api.tasks.jobs,
+    );
+
+    try {
+      await worker.connect();
+
+      const result: (T extends Task
+        ? AsyncReturnType<T["run"]>
+        : { [key: string]: any }) & {
+        error?: string;
+      } = await worker.performInline(
+        taskName,
+        Array.isArray(params) ? params : [params],
+      );
+      await worker.end();
+      return result;
+    } catch (error) {
+      try {
+        worker.end();
+      } catch (error) {}
+      throw error;
+    }
+  }
+
+  /**
+   * Use the specHelper to find enqueued instances of a task
+   * This will return an array of instances of the task which have been enqueued either in the normal queues or delayed queues
+   * If a task is enqueued in a delayed queue, it will have a 'timestamp' property
+   * i.e. [ { class: 'regularTask', queue: 'testQueue', args: [ [Object] ] } ]
+   */
+  export async function findEnqueuedTasks(taskName: string) {
+    let found: TaskInputs[] = [];
+
+    // normal queues
+    const queues = await api.resque.queue.queues();
+    for (const i in queues) {
+      const q = queues[i];
+      const length = await api.resque.queue.length(q);
+      const batchFound = await task.queued(q, 0, length + 1);
+      let matches = batchFound.filter((t) => t.class === taskName);
+      matches = matches.map((m) => {
+        m.timestamp = null;
+        return m;
+      });
+      found = found.concat(matches);
+    }
+
+    // delayed queues
+    const allDelayed = await api.resque.queue.allDelayed();
+    for (const timestamp in allDelayed) {
+      let matches = allDelayed[timestamp].filter((t) => t.class === taskName);
+      matches = matches.map((m) => {
+        m.timestamp = parseInt(timestamp);
+        return m;
+      });
+      found = found.concat(matches);
+    }
+
+    return found;
+  }
+
+  /**
+   * Delete all enqueued instances of a task, both in all the normal queues and all of the delayed queues
+   */
+  export async function deleteEnqueuedTasks(taskName: string, params: {}) {
+    const queues = await api.resque.queue.queues();
+    for (const i in queues) {
+      const q = queues[i];
+      await api.resque.queue.del(q, taskName, [params]);
+      await api.resque.queue.delDelayed(q, taskName, [params]);
+    }
+  }
+}