0z2i6v3u5t 1.0.0

package/src/servers/websocket.ts

@@ -0,0 +1,304 @@
+import * as Primus from "primus";
+import * as fs from "fs";
+import * as path from "path";
+import * as util from "util";
+import * as uuid from "uuid";
+import { api, config, utils, log, Server, Connection } from "../index";
+
+export class WebSocketServer extends Server {
+  server: Primus;
+
+  constructor() {
+    super();
+    this.type = "websocket";
+
+    this.attributes = {
+      canChat: true,
+      logConnections: true,
+      logExits: true,
+      sendWelcomeMessage: true,
+      verbs: [
+        "quit",
+        "exit",
+        "documentation",
+        "roomAdd",
+        "roomLeave",
+        "roomView",
+        "detailsView",
+        "say",
+      ],
+    };
+  }
+
+  async initialize() {
+    // we rely on the web server :D
+  }
+
+  async start() {
+    const webserver = api.servers.servers.web;
+    if (!webserver) {
+      throw new Error(`websocket server requires web server to be enabled`);
+    }
+
+    this.server = new Primus(webserver.server, this.config.server);
+
+    this.writeClientJS();
+
+    this.server.on("connection", (rawConnection) => {
+      this.handleConnection(rawConnection);
+    });
+
+    this.server.on("disconnection", (rawConnection) => {
+      this.handleDisconnection(rawConnection);
+    });
+
+    this.log(
+      `webSockets bound to ${webserver.config.bindIP}:${webserver.config.port}`,
+      "debug",
+    );
+
+    this.on("connection", (connection: Connection) => {
+      connection.rawConnection.on("data", (data: Record<string, any>) => {
+        this.handleData(connection, data);
+      });
+    });
+
+    this.on("actionComplete", (data) => {
+      if (data.toRender !== false) {
+        data.connection.response.messageId = data.messageId;
+        this.sendMessage(data.connection, data.response, data.messageId);
+      }
+    });
+  }
+
+  async stop() {
+    if (!this.server) return;
+
+    if (this.config.destroyClientsOnShutdown === true) {
+      this.connections().forEach((connection: Connection) => {
+        connection.destroy();
+      });
+    }
+
+    //@ts-ignore
+    this.server.destroy();
+  }
+
+  async sendMessage(
+    connection: Connection,
+    message: Record<string, any>,
+    messageId: string,
+  ) {
+    if (message.error) {
+      message.error = config.errors.serializers.servers.websocket(
+        message.error,
+      );
+    }
+
+    if (!message.context) {
+      message.context = "response";
+    }
+    if (!messageId) {
+      messageId = connection.messageId;
+    }
+    if (message.context === "response" && !message.messageId) {
+      message.messageId = messageId;
+    }
+
+    connection.rawConnection.write(message);
+  }
+
+  async sendFile(
+    connection: Connection,
+    error: NodeJS.ErrnoException,
+    fileStream: any,
+    mime: string,
+    length: number,
+    lastModified: Date,
+  ) {
+    const messageId = connection.messageId;
+    let content = "";
+    const response = {
+      error: error,
+      content: null as string,
+      mime: mime,
+      length: length,
+      lastModified: lastModified,
+    };
+
+    try {
+      if (!error) {
+        fileStream.on("data", (d: string) => {
+          content += d;
+        });
+        fileStream.on("end", () => {
+          response.content = content;
+          this.sendMessage(connection, response, messageId);
+        });
+      } else {
+        this.sendMessage(connection, response, messageId);
+      }
+    } catch (e) {
+      this.log(e, "warning");
+      this.sendMessage(connection, response, messageId);
+    }
+  }
+
+  //@ts-ignore
+  goodbye(connection: Connection) {
+    connection.rawConnection.end();
+  }
+
+  compileActionheroWebsocketClientJS() {
+    let ahClientSource = fs
+      .readFileSync(
+        path.join(__dirname, "/../../client/ActionheroWebsocketClient.js"),
+      )
+      .toString();
+    const url = this.config.clientUrl;
+    ahClientSource = ahClientSource.replace(/%%URL%%/g, url);
+    const defaults: {
+      [key: string]: any;
+    } = {};
+
+    for (const i in this.config.client) {
+      defaults[i] = this.config.client[i];
+    }
+
+    defaults.url = url;
+    let defaultsString = util.inspect(defaults);
+    defaultsString = defaultsString.replace(
+      "'window.location.origin'",
+      "window.location.origin",
+    );
+    ahClientSource = ahClientSource.replace(
+      "%%DEFAULTS%%",
+      "return " + defaultsString,
+    );
+
+    return ahClientSource;
+  }
+
+  renderClientJS() {
+    const libSource = api.servers.servers.websocket.server.library();
+    let ahClientSource = this.compileActionheroWebsocketClientJS();
+    ahClientSource =
+      ";;;\r\n" +
+      "(function(exports){ \r\n" +
+      ahClientSource +
+      "\r\n" +
+      "exports.ActionheroWebsocketClient = ActionheroWebsocketClient; \r\n" +
+      "exports.ActionheroWebsocketClient = ActionheroWebsocketClient; \r\n" +
+      "})(typeof exports === 'undefined' ? window : exports);";
+
+    return libSource + "\r\n\r\n\r\n" + ahClientSource;
+  }
+
+  writeClientJS() {
+    if (
+      !config.general.paths.public ||
+      config.general.paths.public.length === 0
+    ) {
+      return;
+    }
+
+    if (this.config.clientJsPath && this.config.clientJsName) {
+      const clientJSPath = path.normalize(
+        config.general.paths.public[0] +
+          path.sep +
+          this.config.clientJsPath +
+          path.sep,
+      );
+      const clientJSName = this.config.clientJsName;
+      const clientJSFullPath = clientJSPath + clientJSName;
+      try {
+        if (!fs.existsSync(clientJSPath)) {
+          fs.mkdirSync(clientJSPath, { recursive: true });
+        }
+        fs.writeFileSync(clientJSFullPath + ".js", this.renderClientJS());
+        log(`wrote ${clientJSFullPath}.js`, "debug");
+      } catch (e) {
+        log("Cannot write client-side JS for websocket server:", "alert", e);
+        throw e;
+      }
+    }
+  }
+
+  handleConnection(rawConnection: Primus.Spark) {
+    const fingerprint =
+      rawConnection.query[config.web.fingerprintOptions.cookieKey];
+    const { ip, port } = utils.parseHeadersForClientAddress(
+      rawConnection.headers,
+    );
+
+    this.buildConnection({
+      rawConnection: rawConnection,
+      remoteAddress: ip || rawConnection.address.ip,
+      remotePort: port || rawConnection.address.port,
+      fingerprint: fingerprint,
+    });
+  }
+
+  handleDisconnection(rawConnection: Primus.Spark) {
+    const connections = this.connections();
+    for (const i in connections) {
+      if (
+        connections[i] &&
+        rawConnection.id === connections[i].rawConnection.id
+      ) {
+        connections[i].destroy();
+        break;
+      }
+    }
+  }
+
+  async handleData(connection: Connection, data: Record<string, any>) {
+    const verb = data.event;
+    delete data.event;
+
+    connection.messageId = data.messageId || uuid.v4();
+    delete data.messageId;
+    connection.params = {};
+
+    if (verb === "action") {
+      for (const v in data.params) {
+        connection.params[v] = data.params[v];
+      }
+      connection.error = null;
+      connection.response = {};
+      return this.processAction(connection);
+    }
+
+    if (verb === "file") {
+      connection.params = {
+        file: data.file,
+      };
+      return this.processFile(connection);
+    }
+
+    const words = [];
+    let message;
+    if (data.room) {
+      words.push(data.room);
+      delete data.room;
+    }
+    for (const i in data) {
+      words.push(data[i]);
+    }
+    const messageId = connection.messageId;
+    try {
+      const data = await connection.verbs(verb, words);
+      message = { status: "OK", context: "response", data: data };
+      return this.sendMessage(connection, message, messageId);
+    } catch (error) {
+      const formattedError = error.toString();
+      message = {
+        status: formattedError,
+        error: formattedError,
+        context: "response",
+        data: data,
+      };
+      return this.sendMessage(connection, message, messageId);
+    }
+  }
+}

package/src/tasks/runAction.ts

@@ -0,0 +1,29 @@
+import { log, Task, action, ParamsFrom } from "./../index";
+
+export class RunAction extends Task {
+  name = "runAction";
+  description = "I will run an action and return the connection object";
+  frequency = 0;
+  queue = "default";
+
+  async run(params: ParamsFrom<RunAction>) {
+    if (!params) params = {};
+
+    const response = await action.run(
+      params.action,
+      params.version,
+      // @ts-ignore
+      params.params,
+    );
+
+    if (response.error) {
+      log("task error: " + response.error, "error", {
+        params: JSON.stringify(params),
+      });
+    } else {
+      log("[ action @ task ]", "debug", { params: JSON.stringify(params) });
+    }
+
+    return response;
+  }
+}

package/tea.yaml

@@ -0,0 +1,9 @@
+# https://tea.xyz/what-is-this-file
+---
+version: 1.0.0
+codeOwners:
+  - '0xa98810E2e6651F5bD3B6228a798e26C4e3C08862'
+  - '0x6EA07435C33111F3A2e8526da031391b209D2637'
+  - '0x3287b8E6A699fDdB844fD7bb5BB1B77bB4673c42'
+  - '0x18Ad36Faa96CadC9553675C8F67077FFa3f266c1'
+quorum: 1

package/templates/README.md.template

@@ -0,0 +1,17 @@
+# My actionhero Project
+
+_visit www.actionherojs.com for more information_
+
+## To install:
+
+(assuming you have [node](http://nodejs.org/), [TypeScript](https://www.typescriptlang.org/), and NPM installed)
+
+`npm install`
+
+## To Run:
+
+`npm start`
+
+## To Test:
+
+`npm test`

package/templates/action.ts.template

@@ -0,0 +1,15 @@
+import { Action } from "actionhero";
+
+export class MyAction extends Action {
+  constructor() {
+    super();
+    this.name = "%%name%%";
+    this.description = "%%description%%";
+    this.outputExample = {};
+  }
+
+  async run(data) {
+    // your logic here
+    data.response.ok = true;
+  }
+}

package/templates/boot.js.template

@@ -0,0 +1,9 @@
+/* This file will load, be required, first in the actionhero binary.
+   Anything that needed loaded or run BEFORE actionhero starts can be done here.
+
+   This file returns a single method that is run immediately after loading.
+*/
+
+// include high-level requires here.
+
+exports.default = async function BOOT() {}

package/templates/cli.ts.template

@@ -0,0 +1,15 @@
+import { CLI } from "actionhero";
+
+export class MyCLICommand extends CLI {
+  constructor() {
+    super();
+    this.name = "%%name%%";
+    this.description = "%%description%%";
+    this.example = "%%example%%";
+    this.inputs = {};
+  }
+
+  async run(data) {
+    return true;
+  }
+}

package/templates/gitignore.template

@@ -0,0 +1,23 @@
+# Actionhero files
+pids/*
+tmp/*
+log/*
+cache/*
+coverage/*
+node_modules/*
+public/javascript/ActionheroWebsocketClient.js
+dist
+
+# Node / NPM
+npm-debug.log
+
+# OS-specific weirdness
+.DS_Store
+
+# Redis
+dump.rdb
+cache.dump
+
+# Editor-specific
+/nbproject/*
+/.idea/*

package/templates/initializer.ts.template

@@ -0,0 +1,17 @@
+import { Initializer } from "actionhero";
+
+export class MyInitializer extends Initializer {
+  constructor() {
+    super();
+    this.name = "%%name%%";
+    this.loadPriority = %%loadPriority%%;
+    this.startPriority = %%startPriority%%;
+    this.stopPriority = %%stopPriority%%;
+  }
+
+  async initialize() {}
+
+  async start() {}
+
+  async stop() {}
+}

package/templates/package-plugin.json.template

@@ -0,0 +1,12 @@
+{
+  "author": "YOU <YOU@example.com>",
+  "name": "my_actionhero_plugin",
+  "description": "my actionhero plugin",
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "peerDependencies": {
+    "actionhero": "%%versionNumber%%"
+  }
+}

package/templates/package.json.template

@@ -0,0 +1,45 @@
+{
+  "author": "YOU <YOU@example.com>",
+  "name": "my_actionhero_project",
+  "description": "my actionhero project",
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "dependencies": {
+    "actionhero": "%%versionNumber%%",
+    "ws": "latest",
+    "ioredis": "latest",
+    "ioredis-mock": "latest",
+    "winston": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "@types/glob": "latest",
+    "@types/jest": "latest",
+    "jest": "latest",
+    "prettier": "latest",
+    "ts-jest": "latest",
+    "ts-node-dev": "latest",
+    "type-fest": "latest",
+    "typescript": "latest"
+  },
+  "scripts": {
+    "postinstall": "npm run build",
+    "dev": "ts-node-dev --no-deps --transpile-only ./src/server",
+    "debug": "tsc && ts-node-dev --transpile-only --no-deps --inspect -- ./src/server ",
+    "start": "node ./dist/server.js",
+    "actionhero": "actionhero",
+    "test": "jest",
+    "pretest": "npm run build && npm run lint",
+    "build": "tsc --sourceMap false --declaration",
+    "lint": "prettier --check src/*/** __tests__/*/**",
+    "pretty": "prettier --write src/*/** __tests__/*/**"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "transform": {
+      "^.+\\.ts?$": "ts-jest"
+    }
+  }
+}

package/templates/projectMap.txt

@@ -0,0 +1,39 @@
+|
+|- src
+|  - server.ts
+|
+|  - config
+|    - (project settings)
+|
+|  - actions
+|    -- (your actions)
+|
+|  - initializers
+|    -- (any additional initializers you want)
+|
+|  - servers
+|    -- (custom servers you may make)
+|
+|  - tasks
+|    -- (your tasks)
+|
+|  - bin
+|    -- (your custom CLI commands)
+|
+|- __tests__
+|-- (tests for your API)
+|
+| - log
+|-- (default location for logs)
+|
+|- node_modules
+|-- (your modules, actionhero should be npm installed in here)
+|
+|- pids
+|-- (pidfiles for your running servers)
+|
+|- public
+|-- (your static assets to be served by /file)
+|
+readme.md
+package.json

package/templates/projectServer.ts.template

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+// load any custom code, configure the env, as needed
+
+async function main() {
+  // create a new actionhero process
+  const { Process } = await import("actionhero");
+  const app = new Process();
+
+  // handle unix signals and uncaught exceptions & rejections
+  app.registerProcessSignals((exitCode) => {
+    process.exit(exitCode);
+  });
+
+  // start the app!
+  // you can pass custom configuration to the process as needed
+  await app.start();
+}
+
+main();

package/templates/server.ts.template

@@ -0,0 +1,37 @@
+import { Server } from "actionhero";
+
+export class MyServer extends Server {
+  constructor() {
+    super();
+    this.type = "%%name%%";
+
+    this.attributes = {
+      canChat: false,
+      logConnections: true,
+      logExits: true,
+      sendWelcomeMessage: false,
+      verbs: []
+    };
+    // this.config will be set to equal config[this.type]
+  }
+
+  async initialize() {
+    this.on("connection", connection => {});
+
+    this.on("actionComplete", data => {});
+  }
+
+  async start() {
+    // this.buildConnection (data)
+    // this.processAction (connection)
+    // this.processFile (connection)
+  }
+
+  async stop() {}
+
+  async sendMessage(connection, message, messageId) {}
+
+  async sendFile(connection, error, fileStream, mime, length, lastModified) {}
+
+  goodbye(connection) {}
+}

package/templates/task.ts.template

@@ -0,0 +1,16 @@
+import { Task } from "actionhero";
+
+export class MyTask extends Task {
+  constructor() {
+    super();
+    this.name = "%%name%%";
+    this.description = "%%description%%";
+    this.frequency = %%frequency%%;
+    this.queue = "%%queue%%";
+    this.middleware = [];
+  }
+
+  async run(data) {
+    // your logic here
+  }
+}

package/templates/test/action.ts.template

@@ -0,0 +1,13 @@
+import { Process, specHelper } from "actionhero";
+
+describe("Action: %%name%%", () => {
+  const actionhero = new Process();
+
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  test("returns OK", async () => {
+    const { ok } = await specHelper.runAction("%%name%%");
+    expect(ok).toEqual(true);
+  });
+});

package/templates/test/task.ts.template

@@ -0,0 +1,20 @@
+import { Process, task, api, specHelper } from "actionhero";
+
+describe("Task: %%name%%", () => {
+  const actionhero = new Process();
+
+  beforeAll(async () => await actionhero.start());
+  afterAll(async () => await actionhero.stop());
+
+  beforeEach(async () => {
+    await api.resque.queue.connection.redis.flushdb();
+  });
+
+  test("can be enqueued", async () => {
+    await task.enqueue("%%name%%", {});
+    const found = await specHelper.findEnqueuedTasks("%%name%%");
+    expect(found.length).toEqual(1);
+    expect(found[0].timestamp).toBeNull();
+  });
+});
+

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "allowJs": true,
+    "module": "commonjs",
+    "target": "es2018",
+    "sourceMap": true,
+    "noImplicitAny": true
+  },
+  "include": ["./src/**/*"]
+}