@joystick.js/node-canary 0.0.0-canary.31 → 0.0.0-canary.310

package/dist/ssr/replaceWhenTags.js

@@ -25,9 +25,8 @@ const flattenAndReplaceWhenElements = (dom = {}, options = {}) => {
 };
 var replaceWhenTags_default = (html = "") => {
   try {
-    const { document: parseHTMLDocument } = parseHTML(html);
-    const dom = flattenAndReplaceWhenElements(parseHTMLDocument);
-    return dom.toString();
+    const whenRegex = new RegExp("<when>|</when>", "g");
+    return html?.replace(whenRegex, "");
   } catch (exception) {
     throw new Error(`[ssr.replaceWhenTags] ${exception.message}`);
   }

package/dist/ssr/setHeadTagsInHTML.js

@@ -28,7 +28,7 @@ var setHeadTagsInHTML_default = (htmlString = "", head = null, req = {}) => {
       const metaTag = head.tags.meta[currentMetaTag];
       const existingTag = headTag.querySelector(`meta[name="${metaTag.name}"]`);
       const newTag = htmlParser.parse(`<meta />`);
-      const metaTagEntries = Object.entries(metaTag);
+      const metaTagEntries = Object.entries(metaTag || {});
       let currentMetaTagEntry = metaTagEntries.length;
       while (currentMetaTagEntry--) {
         const [attributeName, attributeValue] = metaTagEntries[currentMetaTagEntry];
@@ -47,7 +47,7 @@ var setHeadTagsInHTML_default = (htmlString = "", head = null, req = {}) => {
     while (currentLinkTag--) {
       const linkTag = head.tags.link[currentLinkTag];
       const newTag = htmlParser.parse(`<link />`);
-      let linkTagEntries = Object.entries(linkTag);
+      let linkTagEntries = Object.entries(linkTag || {});
       let currentLinkTagEntry = linkTagEntries.length;
       while (currentLinkTagEntry--) {
         const [attributeName, attributeValue] = linkTagEntries[currentLinkTagEntry];
@@ -61,7 +61,7 @@ var setHeadTagsInHTML_default = (htmlString = "", head = null, req = {}) => {
     while (currentScriptTag--) {
       const scriptTag = head.tags.script[currentScriptTag];
       const newTag = htmlParser.parse(`<script><\/script>`);
-      let scriptTagEntries = Object.entries(scriptTag);
+      let scriptTagEntries = Object.entries(scriptTag || {});
       let currentScriptTagEntry = scriptTagEntries.length;
       while (currentScriptTagEntry--) {
         const [attributeName, attributeValue] = scriptTagEntries[currentScriptTagEntry];

package/dist/test/index.js

@@ -0,0 +1,9 @@
+import trackFunctionCall from "./trackFunctionCall.js";
+var test_default = {
+  utils: {
+    trackFunctionCall
+  }
+};
+export {
+  test_default as default
+};

package/dist/test/trackFunctionCall.js

@@ -0,0 +1,17 @@
+var trackFunctionCall_default = (path = "", args = []) => {
+  if (process.env.NODE_ENV === "test") {
+    process.test = {
+      ...process.test || {},
+      functionCalls: {
+        ...process?.test?.functionCalls || {},
+        [path]: [
+          ...process?.test?.functionCalls && process?.test?.functionCalls[path] || [],
+          { calledAt: new Date().toISOString(), args }
+        ]
+      }
+    };
+  }
+};
+export {
+  trackFunctionCall_default as default
+};

package/dist/validation/inputWithSchema/index.js

@@ -47,7 +47,7 @@ const addToValidationQueue = (queue = [], schema = {}, input = {}, parentPath =
   }
   const rulesOnlySchema = !!(schema.type && constants.types.includes(schema.type));
   if (!rulesOnlySchema) {
-    Object.entries(schema).forEach(([field, rules]) => {
+    Object.entries(schema || {}).forEach(([field, rules]) => {
       const path = `${parentPath ? `${parentPath}.${field}` : field}`;
       const validationTask = addValidationTask({
         queue,
@@ -77,12 +77,12 @@ const validateInputWithSchema = async (input = null, schema = null, parentPath =
   if (!input) {
     errors.push("Input is required.");
   }
-  if (schema && Object.keys(schema) && !schema.type) {
+  if (schema && Object.keys(schema || {}) && !schema.type) {
     validateSchema(schema);
   }
   const queue = addToValidationQueue([], schema, input, parentPath);
   await Promise.all(queue.flatMap((validationTask) => {
-    return Object.entries(validationTask.rules).flatMap(async ([ruleName, ruleValue]) => {
+    return Object.entries(validationTask.rules || {}).flatMap(async ([ruleName, ruleValue]) => {
       const validator = constants.rules[ruleName];
       if (validator && !validationTask.path.includes(".$.")) {
         const result = await validator(ruleValue, validationTask.inputValue, validationTask.path);

package/dist/validation/schema/index.js

@@ -2,16 +2,16 @@ import throwError from "../lib/throwError";
 import { isObject } from "../lib/typeValidators";
 import constants from "../lib/constants";
 const validateRuleType = (schema) => {
-  Object.entries(schema).forEach(([field, rules]) => {
+  Object.entries(schema || {}).forEach(([field, rules]) => {
     if (rules && rules.type && !constants.types.includes(rules.type)) {
       throw new Error(`Invalid value for schema field "${field}" type rule. ${rules.type} is not supported. Use one of the following: ${constants.types.slice(0, constants.types.length - 1).join(", ")}, or ${constants.types[constants.types.length - 1]}.`);
     }
   });
 };
 const validateRuleNames = (schema) => {
-  Object.entries(schema).forEach(([field, rules]) => {
-    Object.keys(rules).forEach((ruleName) => {
-      const ruleNames = Object.keys(constants.rules);
+  Object.entries(schema || {}).forEach(([field, rules]) => {
+    Object.keys(rules || {}).forEach((ruleName) => {
+      const ruleNames = Object.keys(constants.rules || {});
       if (!ruleNames.includes(ruleName)) {
         throw new Error(`Invalid rule name ${ruleName} in rule for ${field} field.`);
       }
@@ -19,7 +19,7 @@ const validateRuleNames = (schema) => {
   });
 };
 const validateRulesAreObjects = (schema) => {
-  Object.entries(schema).forEach(([field, rules]) => {
+  Object.entries(schema || {}).forEach(([field, rules]) => {
     if (!isObject(rules)) {
       throw new Error(`Must pass an object containing rules to validate by for ${field} field.`);
     }

package/dist/websockets/index.js

@@ -1,8 +1,12 @@
 import emitWebsocketEvent from "./emitWebsocketEvent";
+import trackFunctionCall from "../test/trackFunctionCall.js";
 var websockets_default = (serverName = "") => {
   return {
     send: (payload = {}, uniqueConnectionId = "") => {
       const emitterName = uniqueConnectionId ? `${serverName}_${uniqueConnectionId}` : serverName;
+      trackFunctionCall(`node.websockets.${serverName}.send`, [
+        payload
+      ]);
       emitWebsocketEvent(emitterName, "message", payload);
     }
   };

package/getSanitizedContext.js

@@ -0,0 +1,43 @@
+export default (context = {}) => {
+  const sanitizedContext = { ...context };
+  
+  if (sanitizedContext?.req) {
+    delete sanitizedContext.req;
+    sanitizedContext.req = {
+      method: context?.req?.method,
+      headers: context?.req?.headers,
+      url: context?.req?.url,
+    };
+  }
+  
+  if (sanitizedContext?.res) {
+    delete sanitizedContext.res;
+    sanitizedContext.res = {
+      method: context?.res?.method,
+      headers: context?.res?.headers,
+      url: context?.res?.url,
+    };
+  }
+  
+  if (sanitizedContext.mongodb) {
+    delete sanitizedContext.mongodb;
+  }
+  
+  if (sanitizedContext.postgresql) {
+    delete sanitizedContext.postgresql;
+  }
+  
+  if (sanitizedContext.redis) {
+    delete sanitizedContext.redis;
+  }
+  
+  if (sanitizedContext._users) {
+    delete sanitizedContext._users;
+  }
+  
+  if (sanitizedContext._queues) {
+    delete sanitizedContext._queues;
+  }
+  
+  return sanitizedContext;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joystick.js/node-canary",
-  "version": "0.0.0-canary.31",
+  "version": "0.0.0-canary.310",
   "type": "module",
   "description": "A Node.js framework for building web apps.",
   "main": "./dist/index.js",
@@ -38,6 +38,7 @@
     "node-html-parser": "^5.1.0",
     "nodemailer": "^6.7.0",
     "pg": "^8.7.3",
+    "pg-escape": "^0.2.0",
     "process": "^0.11.10",
     "query-string": "^7.0.1",
     "sanitize-html": "^2.7.3",

package/dist/app/accounts/roles/index.test.js

@@ -1,123 +0,0 @@
-import { jest } from "@jest/globals";
-import { killPortProcess } from "kill-port-process";
-import setAppSettingsForTest from "../../../tests/lib/setAppSettingsForTest";
-import startTestDatabase from "../../../tests/lib/databases/start";
-import stopTestDatabase from "../../../tests/lib/databases/stop";
-import { beforeEach, expect, test } from "@jest/globals";
-import roles from "./index";
-import accounts from "../index";
-jest.mock("../../../../node_modules/dayjs", () => {
-  const _dayjs = jest.requireActual("../../../../node_modules/dayjs");
-  const _utc = jest.requireActual("../../../../node_modules/dayjs/plugin/utc");
-  _dayjs.extend(_utc);
-  return () => _dayjs("2022-01-01T00:00:00.000Z");
-});
-setAppSettingsForTest({
-  "config": {
-    "databases": [
-      {
-        "provider": "mongodb",
-        "users": true,
-        "options": {}
-      }
-    ],
-    "i18n": {
-      "defaultLanguage": "en-US"
-    },
-    "middleware": {},
-    "email": {
-      "from": "app@test.com",
-      "smtp": {
-        "host": "fake.email.com",
-        "port": 587,
-        "username": "test",
-        "password": "password"
-      }
-    }
-  },
-  "global": {},
-  "public": {},
-  "private": {}
-});
-global.joystick = {
-  settings: {
-    config: {
-      databases: [{
-        "provider": "mongodb",
-        "users": true,
-        "options": {}
-      }]
-    }
-  }
-};
-const app = (await import("../../index")).default;
-let instance;
-describe("app/accounts/roles/index.js", () => {
-  beforeAll(async () => {
-    process.env.PORT = 3600;
-  });
-  beforeEach(async () => {
-    instance = await app({});
-  });
-  afterEach(async () => {
-    if (instance?.server?.close && typeof instance.server.close === "function") {
-      instance.server.close();
-    }
-    await killPortProcess(process.env.PORT);
-  });
-  afterAll(async () => {
-  });
-  test("roles.add adds role to roles collection in database", async () => {
-    await roles.add("admin");
-    const roleExists = await process.databases.mongodb.collection("roles").findOne({ role: "admin" });
-    expect(!!roleExists).toBe(true);
-  });
-  test("roles.remove removes role from roles collection in database", async () => {
-    await roles.add("admin");
-    await roles.remove("admin");
-    const roleExists = await process.databases.mongodb.collection("roles").findOne({ role: "admin" });
-    expect(!!roleExists).toBe(false);
-  });
-  test("roles.list returns a list of roles in the roles collection in database", async () => {
-    await roles.add("admin");
-    await roles.add("manager");
-    await roles.add("employee");
-    const rolesInDatabase = await roles.list();
-    await roles.remove("admin");
-    await roles.remove("manager");
-    await roles.remove("employee");
-    expect(rolesInDatabase).toEqual(["admin", "manager", "employee"]);
-  });
-  test("roles.grant adds role to user in users collection in database", async () => {
-    await process.databases.mongodb.collection("users").deleteOne({ emailAddress: "test@test.com" });
-    const user = await accounts.signup({ emailAddress: "test@test.com", password: "password" });
-    await roles.grant(user?.userId, "admin");
-    await roles.grant(user?.userId, "rolethatdoesntexist");
-    const userAfterGrant = await process.databases.mongodb.collection("users").findOne({ _id: user?.userId });
-    const rolesCreated = await process.databases.mongodb.collection("roles").find().toArray();
-    expect(userAfterGrant?.roles?.includes("admin")).toBe(true);
-    expect(rolesCreated?.length).toBe(2);
-  });
-  test("roles.revoke removes role from user in users collection in database", async () => {
-    await process.databases.mongodb.collection("users").deleteOne({ emailAddress: "test@test.com" });
-    const user = await accounts.signup({ emailAddress: "test@test.com", password: "password" });
-    await roles.grant(user?.userId, "admin");
-    await roles.revoke(user?.userId, "admin");
-    const userAfterGrant = await process.databases.mongodb.collection("users").findOne({ _id: user?.userId });
-    expect(userAfterGrant?.roles?.includes("admin")).toBe(false);
-  });
-  test("roles.userHasRole returns true if user has role", async () => {
-    await process.databases.mongodb.collection("users").deleteOne({ emailAddress: "test@test.com" });
-    const user = await accounts.signup({ emailAddress: "test@test.com", password: "password" });
-    await roles.grant(user?.userId, "admin");
-    const userHasRole = await roles.userHasRole(user?.userId, "admin");
-    expect(userHasRole).toBe(true);
-  });
-  test("roles.userHasRole returns false if user does not have role", async () => {
-    await process.databases.mongodb.collection("users").deleteOne({ emailAddress: "test@test.com" });
-    const user = await accounts.signup({ emailAddress: "test@test.com", password: "password" });
-    await roles.grant(user?.userId, "admin");
-    const userHasRole = await roles.userHasRole(user?.userId, "manager");
-    expect(userHasRole).toBe(false);
-  });
-});