0z2i6v3u5t 1.0.0

package/src/bin/methods/generate/server.ts

@@ -0,0 +1,38 @@
+import * as fs from "fs";
+import * as path from "path";
+import { config, utils, CLI, ParamsFrom } from "./../../../index";
+
+export class GenerateServerCLI extends CLI {
+  name = "generate-server";
+  description = "Generate a new Server";
+  example = "actionhero generate server --name=<name>";
+  inputs = {
+    name: {
+      required: true as true,
+      description: "The name of the Server to generate",
+      letter: "n",
+    },
+  };
+
+  async run({ params }: { params: ParamsFrom<GenerateServerCLI> }) {
+    let templateBuffer = fs.readFileSync(
+      path.join(__dirname, "/../../../../templates/server.ts.template"),
+    );
+    let template = String(templateBuffer);
+
+    for (const [k, v] of Object.entries(params)) {
+      const regex = new RegExp("%%" + k + "%%", "g");
+      template = template.replace(regex, v);
+    }
+
+    const message = utils.fileUtils.createFileSafely(
+      utils.replaceDistWithSrc(
+        config.general.paths.server[0] + "/" + params.name + ".ts",
+      ),
+      template,
+    );
+    console.log(message);
+
+    return true;
+  }
+}

package/src/bin/methods/generate/task.ts

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import * as path from "path";
+import { config, utils, CLI, ParamsFrom } from "./../../../index";
+
+export class GenerateTaskCLI extends CLI {
+  name = "generate-task";
+  description = "Generate a new Task";
+  example =
+    "actionhero generate task --name=<name> -queue=<queue> --description=[description] --frequency=[frequency]";
+  inputs = {
+    name: {
+      required: true as true,
+      description: "The name of the Task to generate",
+      letter: "n",
+    },
+    queue: {
+      required: true as true,
+      description: "The queue that this Task will run on",
+      letter: "q",
+    },
+    description: {
+      required: true as true,
+      description: "The description of this Task",
+      default: "an actionhero task",
+      letter: "d",
+    },
+    frequency: {
+      required: true as true,
+      description: "Should this Task run periodically? Frequency is in ms",
+      default: "0",
+      letter: "f",
+    },
+  };
+
+  async run({ params }: { params: ParamsFrom<GenerateTaskCLI> }) {
+    let taskTemplateBuffer = fs.readFileSync(
+      path.join(__dirname, "/../../../../templates/task.ts.template"),
+    );
+    let taskTemplate = String(taskTemplateBuffer);
+
+    let testTemplateBuffer = fs.readFileSync(
+      path.join(__dirname, "/../../../../templates/test/task.ts.template"),
+    );
+    let testTemplate = String(testTemplateBuffer);
+
+    for (const [k, v] of Object.entries(params)) {
+      const regex = new RegExp("%%" + k + "%%", "g");
+      taskTemplate = taskTemplate.replace(regex, v);
+      testTemplate = testTemplate.replace(regex, v);
+    }
+
+    let message = utils.fileUtils.createFileSafely(
+      utils.replaceDistWithSrc(
+        config.general.paths.task[0] + "/" + params.name + ".ts",
+      ),
+      taskTemplate,
+    );
+    console.info(message);
+
+    message = utils.fileUtils.createFileSafely(
+      config.general.paths.test[0] + "/tasks/" + params.name + ".ts",
+      testTemplate,
+    );
+    console.info(message);
+
+    return true;
+  }
+}

package/src/bin/methods/generate.ts

@@ -0,0 +1,176 @@
+import * as fs from "fs";
+import * as path from "path";
+
+// import { api, projectRoot, CLI } from "./../../index";
+// we need to load each component directly so we don't accidentally source `config... which doesn't exist`
+import { CLI } from "./../../classes/cli";
+import { projectRoot } from "./../../classes/process/projectRoot";
+import {
+  createDirSafely,
+  createFileSafely,
+} from "../../modules/utils/fileUtils";
+
+export class GenerateCLI extends CLI {
+  name = "generate";
+  description = "Generate a new Actionhero Project in an empty directory";
+  initialize = false;
+
+  async run() {
+    const documents: {
+      [key: string]: string | NodeJS.ArrayBufferView;
+    } = {};
+
+    documents.projectMap = fs
+      .readFileSync(path.join(__dirname, "/../../../templates/projectMap.txt"))
+      .toString();
+
+    const oldFileMap = {
+      tsconfig: "tsconfig.json",
+      serverJs: "/templates/projectServer.ts.template",
+      configApiJs: "/src/config/api.ts",
+      configLoggerJs: "/src/config/logger.ts",
+      configRedisJs: "/src/config/redis.ts",
+      configTasksJs: "/src/config/tasks.ts",
+      configErrorsJs: "/src/config/errors.ts",
+      configPluginsJs: "/src/config/plugins.ts",
+      configRoutesJs: "/src/config/routes.ts",
+      configWebJs: "/src/config/web.ts",
+      configWebsocketJs: "/src/config/websocket.ts",
+      packageJson: "/package.json",
+      actionStatus: "/src/actions/status.ts",
+      actionChatRoom: "/src/actions/createChatRoom.ts",
+      actionSwagger: "/src/actions/swagger.ts",
+      publicIndex: "/public/index.html",
+      publicChat: "/public/chat.html",
+      publicSwagger: "/public/swagger.html",
+      publicLogo: "/public/logo/actionhero.png",
+      publicCss: "/public/css/cosmo.css",
+      exampleTest: "/__tests__/template.ts.example",
+      gitignore: "/templates/gitignore.template",
+    };
+
+    for (const [name, localPath] of Object.entries(oldFileMap)) {
+      const source = path.join(__dirname, "/../../../", localPath);
+      const extension = localPath.split(".")[1];
+      documents[name] = fs.readFileSync(source);
+      if (extension === "ts" || extension === "js" || extension === "json") {
+        documents[name] = documents[name]
+          .toString()
+          .replace('from "./../index"', 'from "actionhero"')
+          .replace('from ".."', 'from "actionhero"')
+          .replace('declare module ".."', 'declare module "actionhero"');
+      }
+    }
+
+    const AHversionNumber = JSON.parse(
+      documents.packageJson.toString(),
+    ).version;
+
+    documents.packageJson = String(
+      fs.readFileSync(
+        path.join(__dirname, "/../../../templates/package.json.template"),
+      ),
+    );
+
+    documents.packageJson = documents.packageJson.replace(
+      "%%versionNumber%%",
+      AHversionNumber,
+    );
+
+    documents.readmeMd = String(
+      fs.readFileSync(
+        path.join(__dirname, "/../../../templates/README.md.template"),
+      ),
+    );
+
+    console.log("Generating a new actionhero project...");
+
+    [
+      "/src",
+      "/src/config",
+      "/src/actions",
+      "/src/tasks",
+      "/src/initializers",
+      "/src/servers",
+      "/src/bin",
+      "/log",
+      "/pids",
+      "/public",
+      "/public/javascript",
+      "/public/css",
+      "/public/logo",
+      "/__tests__",
+      "/__tests__/actions",
+      "/__tests__/tasks",
+    ].forEach((dir) => {
+      try {
+        const message = createDirSafely(projectRoot + dir);
+        console.log(message);
+      } catch (error) {
+        console.log(error.toString());
+      }
+    });
+
+    const newFileMap = {
+      "/tsconfig.json": "tsconfig",
+      "/src/server.ts": "serverJs",
+      "/src/config/api.ts": "configApiJs",
+      "/src/config/logger.ts": "configLoggerJs",
+      "/src/config/redis.ts": "configRedisJs",
+      "/src/config/tasks.ts": "configTasksJs",
+      "/src/config/errors.ts": "configErrorsJs",
+      "/src/config/plugins.ts": "configPluginsJs",
+      "/src/config/routes.ts": "configRoutesJs",
+      "/src/config/web.ts": "configWebJs",
+      "/src/config/websocket.ts": "configWebsocketJs",
+      "/package.json": "packageJson",
+      "/src/actions/status.ts": "actionStatus",
+      "/src/actions/createChatRoom.ts": "actionChatRoom",
+      "/src/actions/swagger.ts": "actionSwagger",
+      "/public/index.html": "publicIndex",
+      "/public/chat.html": "publicChat",
+      "/public/swagger.html": "publicSwagger",
+      "/public/css/cosmo.css": "publicCss",
+      "/public/logo/actionhero.png": "publicLogo",
+      "/README.md": "readmeMd",
+      "/__tests__/actions/status.ts": "exampleTest",
+      "/.gitignore": "gitignore",
+    };
+
+    for (const [file, name] of Object.entries(newFileMap)) {
+      try {
+        const message = createFileSafely(projectRoot + file, documents[name]);
+        console.log(message);
+      } catch (error) {
+        console.log(error.toString());
+      }
+    }
+
+    console.log("");
+    console.log(
+      "Generation Complete.  Your project directory should look like this:",
+    );
+
+    console.log("");
+    documents.projectMap
+      .toString()
+      .split("\n")
+      .forEach((line) => {
+        console.log(line);
+      });
+
+    console.log(
+      `
+-------------------------------------------------------------------------------------------------------------------
+You need to run \`npm install\` to install dependencies, and then \`npm run build\` to build the .js from this .ts project.
+Then, run 'npm run dev' to start your server
+
+❤️  the Actionhero Team
+www.actionherojs.com
+-------------------------------------------------------------------------------------------------------------------
+      `,
+    );
+
+    return true;
+  }
+}

package/src/bin/methods/task/enqueue.ts

@@ -0,0 +1,35 @@
+import { api, log, task, CLI, ParamsFrom } from "./../../../index";
+
+export class TaskEnqueueCLI extends CLI {
+  name = "task-enqueue";
+  description = "Enqueue a defined Task into your actionhero cluster";
+  example =
+    "actionhero task enqueue --name=[taskName] --args=[JSON-encoded args]";
+  inputs = {
+    name: {
+      required: true as true,
+      description: "The name of the Task to enqueue",
+      letter: "n",
+    },
+    args: {
+      required: false,
+      description: "Arguments to the Task (JSON encoded)",
+      letter: "a",
+    },
+  };
+
+  async run({ params }: { params: ParamsFrom<TaskEnqueueCLI> }) {
+    if (!api.tasks.tasks[params.name]) {
+      throw new Error('Task "' + params.name + '" not found');
+    }
+
+    let args = {};
+    if (params.args) {
+      args = JSON.parse(params.args);
+    }
+
+    const toRun = await task.enqueue(params.name, args);
+    log(`enqueued: ${toRun}`, "info");
+    return true;
+  }
+}

package/src/classes/action.ts

@@ -0,0 +1,98 @@
+import { api } from "../index";
+import type { ActionheroLogLevel } from "../modules/log";
+import { ActionProcessor } from "./actionProcessor";
+import { connectionVerbs } from "./connection";
+import { Inputs } from "./inputs";
+
+/**
+ * Create a new Actionhero Action. The required properties of an action. These can be defined statically (this.name) or as methods which return a value.
+ *```js
+ * import { Action } from "actionhero";
+ *
+ * export default class RandomNumber extends Action {
+ *  constructor () {
+ *    super()
+ *    this.name = 'randomNumber'
+ *    this.description = 'I am an API method which will generate a random number'
+ *    this.outputExample = { randomNumber: 0.1234 }
+ *  }
+ *  async run ({ response }) {
+ *    response.randomNumber = Math.random()
+ *  }
+ *}
+ *```
+ */
+export abstract class Action {
+  /**The name of the Action*/
+  name: string;
+  /**The description of the Action (default this.name)*/
+  description: string;
+  /**The version of this Action (default: 1) */
+  version?: number | string;
+  //*An example response payload  (default: {})
+  outputExample?: object;
+  /**The inputs of the Action (default: {}) */
+  inputs?: Inputs;
+  /**The Middleware specific to this Action (default: []).  Middleware is described by the string names of the middleware. */
+  middleware?: Array<string>;
+  /**Are there connections from any servers which cannot use this Action (default: [])? */
+  blockedConnectionTypes?: Array<string>;
+  /**Under what level should connections to this Action be logged (default 'info')? */
+  logLevel?: ActionheroLogLevel;
+  /**If this Action is responding to a `web` request, and that request has a file extension like *.jpg, should Actionhero set the response headers to match that extension (default: true)? */
+  matchExtensionMimeType?: boolean;
+  /**Should this Action appear in api.documentation.documentation? (default: true)? */
+  toDocument?: boolean;
+
+  constructor() {
+    this.version = this.version ?? 1;
+    this.description = this.description ?? this.name;
+    this.inputs = this.inputs ?? {};
+    this.outputExample = this.outputExample ?? {};
+    this.middleware = this.middleware ?? [];
+    this.blockedConnectionTypes = this.blockedConnectionTypes ?? [];
+    this.logLevel = this.logLevel ?? "info";
+    this.toDocument = this.toDocument ?? true;
+    this.matchExtensionMimeType = this.matchExtensionMimeType ?? true;
+  }
+
+  /**
+   * The main "do something" method for this action.  It can be `async`.  Usually the goal of this run method is to return the data that you want to be sent to API consumers.  If error is thrown in this method, it will be logged, caught, and returned to the client as `error`
+   * @param data The data about this connection, response, and params.
+   */
+  abstract run(
+    data: Partial<ActionProcessor<Action>>,
+  ): Promise<ActionResponse | void>;
+
+  validate() {
+    if (!this.name) {
+      throw new Error("name is required for this action");
+    }
+    if (!this.description) {
+      throw new Error(
+        `description is required for the action \`${this.name}\``,
+      );
+    }
+    if (!this.run || typeof this.run !== "function") {
+      throw new Error(`action \`${this.name}\` has no run method`);
+    }
+    if (
+      api.connections &&
+      ([...connectionVerbs] as string[]).includes(this.name)
+    ) {
+      throw new Error(
+        `action \`${this.name}\` is a reserved verb for connections. choose a new name`,
+      );
+    }
+
+    Object.keys(this.inputs).forEach((input) => {
+      if (api.params.globalSafeParams.includes(input)) {
+        throw new Error(
+          `input \`${input}\` in action \`${this.name}\` is a reserved param`,
+        );
+      }
+    });
+  }
+}
+
+export type ActionResponse = { [key: string]: any } | null | void;