0z2i6v3u5t 1.0.0

package/__tests__/modules/action.ts

@@ -0,0 +1,103 @@
+import {
+  action,
+  Process,
+  api,
+  Connection,
+  ActionProcessor,
+} from "./../../src/index";
+
+const actionhero = new Process();
+
+describe("Modules", () => {
+  describe("action", () => {
+    beforeAll(async () => {
+      await actionhero.start();
+    });
+
+    afterAll(async () => {
+      await actionhero.stop();
+    });
+
+    test("actions can be called in-line", async () => {
+      const response = await action.run("randomNumber");
+      expect(response.randomNumber).toBeGreaterThanOrEqual(0);
+      expect(response.stringRandomNumber).toMatch(/Your random number is/);
+    });
+
+    test("in-line actions can accept params", async () => {
+      // @ts-ignore
+      const response = await action.run("cacheTest", null, {
+        key: "testKey",
+        value: "testValue",
+      });
+      expect(response.cacheTestResults.saveResp).toBe(true);
+      expect(response.cacheTestResults.deleteResp).toBe(true);
+    });
+
+    test("in-line actions will fail when required params are missing", async () => {
+      await expect(action.run("cacheTest")).rejects.toThrow(
+        /key is a required parameter for this action/,
+      );
+    });
+
+    describe("middleware", () => {
+      afterEach(() => {
+        api.actions.middleware = {};
+        api.actions.globalMiddleware = [];
+      });
+
+      test("in-line actions run middleware", async () => {
+        action.addMiddleware({
+          name: "test middleware",
+          global: true,
+          preProcessor: (data: ActionProcessor<any>) => {
+            data.response._preProcessorNote = "note";
+          },
+        });
+
+        const response = await action.run("randomNumber");
+        expect(response.randomNumber).toBeGreaterThanOrEqual(0);
+        expect(response._preProcessorNote).toBe("note");
+      });
+
+      test("throwing in middleware halts in-line actions", async () => {
+        action.addMiddleware({
+          name: "test middleware",
+          global: true,
+          preProcessor: () => {
+            throw new Error("nope");
+          },
+        });
+
+        await expect(action.run("randomNumber")).rejects.toThrow(/nope/);
+      });
+    });
+
+    describe("connectionProperties", () => {
+      afterEach(() => {
+        api.actions.middleware = {};
+        api.actions.globalMiddleware = [];
+      });
+
+      test("connection properties can be assigned", async () => {
+        action.addMiddleware({
+          name: "test middleware",
+          global: true,
+          preProcessor: ({ connection }: { connection: Connection }) => {
+            if (!connection?.session?.userId) throw new Error("not logged in");
+          },
+        });
+
+        await expect(action.run("randomNumber")).rejects.toThrow(
+          /not logged in/,
+        );
+
+        // @ts-ignore
+        const response = await action.run("randomNumber", null, null, {
+          session: { userId: 123 },
+        });
+        expect(response.randomNumber).toBeGreaterThanOrEqual(0);
+      });
+    });
+  });
+});

package/__tests__/modules/config.ts

@@ -0,0 +1,19 @@
+import { config } from "../../src/index";
+import { rebuildConfig } from "../../src/modules/config";
+
+describe("config class", () => {
+  it("loads config", () => {
+    // statically defined
+    expect(config.general!.cachePrefix).toBe("actionhero:cache:");
+    // generated from another config file
+    expect(config.web!.httpHeaders!["X-Powered-By"]).toBe("actionhero");
+  });
+
+  it("updates config on 'restart'", () => {
+    const port = "2020";
+    process.env.PORT = port;
+    expect(config.web!.port).not.toBe(port);
+    rebuildConfig();
+    expect(config.web!.port).toBe(port);
+  });
+});

package/__tests__/modules/utils/ensureNoTsHeaderOrSpecFiles.ts

@@ -0,0 +1,24 @@
+import { ensureNoTsHeaderOrSpecFiles } from "../../../src/modules/utils/ensureNoTsHeaderOrSpecFiles";
+
+describe("ensureNoTsHeaderOrSpecFiles", () => {
+  it("filters header files", () => {
+    const filtered = ensureNoTsHeaderOrSpecFiles([
+      "afdasf.d.ts",
+      "some-file.ts",
+    ]);
+    expect(filtered).toEqual(["some-file.ts"]);
+  });
+
+  it("filters test/spec files", () => {
+    const filtered = ensureNoTsHeaderOrSpecFiles([
+      "afdasf.spec.ts",
+      "afdasfsdfa.spec.js",
+      "spec.js",
+      "test-my-api.js",
+      "afdasfsdfa.test.js",
+      "afdasfsdfa.test.ts",
+      "some-file.ts",
+    ]);
+    expect(filtered).toEqual(["spec.js", "test-my-api.js", "some-file.ts"]);
+  });
+});

package/__tests__/servers/web/allowedRequestHosts.ts

@@ -0,0 +1,88 @@
+import axios, { AxiosError } from "axios";
+import { Process, config } from "./../../../src/index";
+
+const actionhero = new Process();
+let url: string;
+
+jest.mock("./../../../src/config/web.ts", () => ({
+  __esModule: true,
+  test: {
+    web: () => {
+      return {
+        enabled: true,
+        secure: false,
+        automaticRoutes: ["get"],
+        allowedRequestHosts: ["https://www.site.com"],
+        urlPathForActions: "api",
+        urlPathForFiles: "public",
+        rootEndpointType: "file",
+        port: 18080 + parseInt(process.env.JEST_WORKER_ID || "0"),
+        matchExtensionMime: true,
+        metadataOptions: {
+          serverInformation: true,
+          requesterInformation: false,
+        },
+        fingerprintOptions: {
+          cookieKey: "sessionID",
+        },
+      };
+    },
+  },
+}));
+
+describe("Server: Web", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  describe("request redirection (allowedRequestHosts)", () => {
+    test("will redirect clients if they do not request the proper host", async () => {
+      try {
+        await axios.get(url + "/api/randomNumber", {
+          maxRedirects: 0,
+          headers: { Host: "lalala.site.com" },
+        });
+        throw new Error("should not get here");
+      } catch (error) {
+        if (error instanceof AxiosError) {
+          expect(error.response?.status).toEqual(302);
+          expect(error.response?.data).toMatch(
+            /You are being redirected to https:\/\/www.site.com\/api\/randomNumber/,
+          );
+        } else throw error;
+      }
+    });
+
+    test("will redirect clients if they do not request the proper protocol", async () => {
+      try {
+        await axios.get(url + "/api/randomNumber", {
+          maxRedirects: 0,
+          headers: { Host: "www.site.com" },
+        });
+        throw new Error("should not get here");
+      } catch (error) {
+        if (error instanceof AxiosError) {
+          expect(error.response?.status).toEqual(302);
+          expect(error.response?.data).toMatch(
+            /You are being redirected to https:\/\/www.site.com\/api\/randomNumber/,
+          );
+        } else throw error;
+      }
+    });
+
+    test("will allow API access from the proper hosts", async () => {
+      const response = await axios.get(url + "/api/randomNumber", {
+        maxRedirects: 0,
+        headers: {
+          Host: "www.site.com",
+          "x-forwarded-proto": "https",
+        },
+      });
+
+      expect(response.data["randomNumber"]).not.toBeUndefined();
+    });
+  });
+});

package/__tests__/servers/web/enableMultiples.ts

@@ -0,0 +1,83 @@
+import { PassThrough } from "stream";
+import axios, { AxiosError } from "axios";
+import { api, Process, config } from "./../../../src/index";
+import * as FormData from "form-data";
+
+const actionhero = new Process();
+let url: string;
+
+jest.mock("./../../../src/config/web.ts", () => ({
+  __esModule: true,
+  test: {
+    web: () => {
+      return {
+        enabled: true,
+        saveRawBody: true,
+        automaticRoutes: ["post"],
+        secure: false,
+        urlPathForActions: "api",
+        urlPathForFiles: "public",
+        rootEndpointType: "file",
+        port: 18080 + parseInt(process.env.JEST_WORKER_ID || "0"),
+        matchExtensionMime: true,
+        metadataOptions: {
+          serverInformation: true,
+          requesterInformation: false,
+        },
+        fingerprintOptions: {
+          cookieKey: "sessionID",
+        },
+        formOptions: { multiples: true },
+      };
+    },
+  },
+}));
+
+describe("Server: Web", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  describe("connection.rawConnection.rawBody", () => {
+    beforeAll(() => {
+      api.actions.versions.paramTestAction = [1];
+      api.actions.actions.paramTestAction = {
+        // @ts-ignore
+        1: {
+          name: "paramTestAction",
+          description: "I return connection.rawConnection.params",
+          version: 1,
+          inputs: { key: { required: true } },
+          run: async (data) => {
+            data.response!.data = data.params;
+          },
+        },
+      };
+
+      api.routes.loadRoutes();
+    });
+
+    afterAll(() => {
+      delete api.actions.actions.paramTestAction;
+      delete api.actions.versions.paramTestAction;
+    });
+
+    test(".rawBody will contain the raw POST body without parsing", async () => {
+      var bodyFormData = new FormData();
+      bodyFormData.append("key", "value");
+      bodyFormData.append("key", "value1");
+
+      const response = await axios.post(
+        url + "/api/paramTestAction",
+        bodyFormData,
+        {
+          headers: { "Content-type": "multipart/form-data" },
+        },
+      );
+      expect(response.data.data.key).toEqual(["value", "value1"]);
+    });
+  });
+});

package/__tests__/servers/web/fileUpload.ts

@@ -0,0 +1,79 @@
+process.env.AUTOMATIC_ROUTES = "head,get,post,put,delete";
+// process.env.LOG_LEVEL = "info";
+
+import axios, { AxiosError } from "axios";
+import * as FormData from "form-data";
+import * as fs from "fs";
+import * as path from "path";
+import { api, Process, config } from "./../../../src/index";
+import { sleep } from "../../../src/modules/utils/sleep";
+
+describe("Server: Web", () => {
+  const actionhero = new Process();
+  let url: string;
+
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  beforeAll(() => {
+    config.web!.returnErrorCodes = true;
+    api.actions.versions.uploadAction = [1];
+    api.actions.actions.uploadAction = {
+      // @ts-ignore
+      1: {
+        name: "uploadAction",
+        description: "I am a test",
+        version: 1,
+        inputs: {
+          file: { required: true },
+          stringParam: { required: true },
+        },
+        outputExample: {},
+        run: async (data) => {
+          await sleep(1000 * 1);
+          return { params: data.params };
+        },
+      },
+    };
+
+    api.routes.loadRoutes();
+  });
+
+  afterAll(() => {
+    delete api.actions.actions.uploadAction;
+    delete api.actions.versions.uploadAction;
+  });
+
+  test("files can be uploaded", async () => {
+    const form = new FormData();
+    form.append("stringParam", "hello world");
+    form.append(
+      "file",
+      fs.createReadStream(
+        path.join(
+          __dirname,
+          "..",
+          "..",
+          "..",
+          "public",
+          "logo",
+          "actionhero.png",
+        ),
+      ),
+    );
+
+    const response = await axios.post(`${url}/api/uploadAction`, form);
+    expect(response.data.params.stringParam).toEqual("hello world");
+    expect(response.data.params.file).toEqual(
+      expect.objectContaining({
+        originalFilename: "actionhero.png",
+        mimetype: "image/png",
+        size: 59273,
+      }),
+    );
+  });
+});

package/__tests__/servers/web/jsonp.ts

@@ -0,0 +1,57 @@
+import axios, { AxiosError } from "axios";
+import { Process, config } from "./../../../src/index";
+
+const actionhero = new Process();
+let url: string;
+
+jest.mock("./../../../src/config/web.ts", () => ({
+  __esModule: true,
+  test: {
+    web: () => {
+      return {
+        enabled: true,
+        automaticRoutes: ["get", "post"],
+        secure: false,
+        urlPathForActions: "api",
+        urlPathForFiles: "public",
+        rootEndpointType: "file",
+        port: 18080 + parseInt(process.env.JEST_WORKER_ID || "0"),
+        matchExtensionMime: true,
+        metadataOptions: {
+          serverInformation: true,
+          requesterInformation: false,
+        },
+        fingerprintOptions: {
+          cookieKey: "sessionID",
+        },
+      };
+    },
+  },
+}));
+
+describe("Server: Web", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  describe("JSONp", () => {
+    test("can ask for JSONp responses", async () => {
+      const response = await axios.get(
+        url + "/api/randomNumber?callback=myCallback",
+      );
+      expect(response.data).toContain("myCallback({");
+      expect(response.data).toContain("Your random number is");
+    });
+
+    test("JSONp responses cannot be used for XSS", async () => {
+      const response = await axios.get(
+        url + "/api/randomNumber?callback=alert(%27hi%27);foo",
+      );
+      expect(response.data).not.toMatch(/alert\(/);
+      expect(response.data.indexOf("alert'hi';foo(")).toEqual(0);
+    });
+  });
+});

package/__tests__/servers/web/nonMultiples.ts

@@ -0,0 +1,83 @@
+import { PassThrough } from "stream";
+import axios, { AxiosError } from "axios";
+import { api, Process, config } from "./../../../src/index";
+import * as FormData from "form-data";
+
+const actionhero = new Process();
+let url: string;
+
+jest.mock("./../../../src/config/web.ts", () => ({
+  __esModule: true,
+  test: {
+    web: () => {
+      return {
+        enabled: true,
+        saveRawBody: true,
+        automaticRoutes: ["post"],
+        secure: false,
+        urlPathForActions: "api",
+        urlPathForFiles: "public",
+        rootEndpointType: "file",
+        port: 18080 + parseInt(process.env.JEST_WORKER_ID || "0"),
+        matchExtensionMime: true,
+        metadataOptions: {
+          serverInformation: true,
+          requesterInformation: false,
+        },
+        fingerprintOptions: {
+          cookieKey: "sessionID",
+        },
+        formOptions: { multiples: false },
+      };
+    },
+  },
+}));
+
+describe("Server: Web", () => {
+  beforeAll(async () => {
+    await actionhero.start();
+    url = "http://localhost:" + config.web!.port;
+  });
+
+  afterAll(async () => await actionhero.stop());
+
+  describe("connection.rawConnection.rawBody", () => {
+    beforeAll(() => {
+      api.actions.versions.paramTestAction = [1];
+      api.actions.actions.paramTestAction = {
+        // @ts-ignore
+        1: {
+          name: "paramTestAction",
+          description: "I return connection.rawConnection.params",
+          version: 1,
+          inputs: { key: { required: true } },
+          run: async (data) => {
+            data.response!.data = data.params;
+          },
+        },
+      };
+
+      api.routes.loadRoutes();
+    });
+
+    afterAll(() => {
+      delete api.actions.actions.paramTestAction;
+      delete api.actions.versions.paramTestAction;
+    });
+
+    test(".rawBody will contain the raw POST body without parsing", async () => {
+      var bodyFormData = new FormData();
+      bodyFormData.append("key", "value");
+      bodyFormData.append("key", "value1");
+
+      const response = await axios.post(
+        url + "/api/paramTestAction",
+        bodyFormData,
+        {
+          headers: { "Content-type": "multipart/form-data" },
+        },
+      );
+      expect(response.data.data.key).toEqual("value1");
+    });
+  });
+});