@joystick.js/node-canary 0.0.0-canary.47 → 0.0.0-canary.471

package/dist/ssr/setHeadTagsInHTML.js

@@ -1,84 +0,0 @@
-import htmlParser from "node-html-parser";
-var setHeadTagsInHTML_default = (htmlString = "", head = null, req = {}) => {
-  const html = htmlParser.parse(htmlString);
-  const headTag = html.querySelector("head");
-  if (req?.context?.session) {
-    const metaTagWrapper = htmlParser.parse(`<meta />`);
-    const tag = metaTagWrapper.querySelector("meta");
-    tag.setAttribute("name", "csrf");
-    tag.setAttribute("content", req?.context?.session?.csrf);
-    headTag.appendChild(tag);
-  }
-  if (!head) {
-    return html.toString();
-  }
-  if (head.title) {
-    const existingTitle = headTag.querySelector("title");
-    if (existingTitle) {
-      const newTitle = htmlParser.parse(`<title>${head.title}</title>`);
-      headTag.exchangeChild(existingTitle, newTitle);
-    }
-    if (!existingTitle) {
-      headTag.insertAdjacentHTML("afterbegin", `<title>${head.title}</title>`);
-    }
-  }
-  if (head.tags && head.tags.meta && Array.isArray(head.tags.meta) && head.tags.meta.length > 0) {
-    let currentMetaTag = head.tags.meta.length;
-    while (currentMetaTag--) {
-      const metaTag = head.tags.meta[currentMetaTag];
-      const existingTag = headTag.querySelector(`meta[name="${metaTag.name}"]`);
-      const newTag = htmlParser.parse(`<meta />`);
-      const metaTagEntries = Object.entries(metaTag);
-      let currentMetaTagEntry = metaTagEntries.length;
-      while (currentMetaTagEntry--) {
-        const [attributeName, attributeValue] = metaTagEntries[currentMetaTagEntry];
-        newTag.querySelector("meta").setAttribute(attributeName, attributeValue);
-      }
-      if (existingTag) {
-        headTag.exchangeChild(existingTag, newTag);
-      }
-      if (!existingTag) {
-        headTag.appendChild(newTag);
-      }
-    }
-  }
-  if (head.tags && head.tags.link && Array.isArray(head.tags.link) && head.tags.link.length > 0) {
-    let currentLinkTag = head.tags.link.length;
-    while (currentLinkTag--) {
-      const linkTag = head.tags.link[currentLinkTag];
-      const newTag = htmlParser.parse(`<link />`);
-      let linkTagEntries = Object.entries(linkTag);
-      let currentLinkTagEntry = linkTagEntries.length;
-      while (currentLinkTagEntry--) {
-        const [attributeName, attributeValue] = linkTagEntries[currentLinkTagEntry];
-        newTag.querySelector("link").setAttribute(attributeName, attributeValue);
-      }
-      headTag.appendChild(newTag);
-    }
-  }
-  if (head.tags && head.tags.script && Array.isArray(head.tags.script) && head.tags.script.length > 0) {
-    let currentScriptTag = head.tags.script.length;
-    while (currentScriptTag--) {
-      const scriptTag = head.tags.script[currentScriptTag];
-      const newTag = htmlParser.parse(`<script><\/script>`);
-      let scriptTagEntries = Object.entries(scriptTag);
-      let currentScriptTagEntry = scriptTagEntries.length;
-      while (currentScriptTagEntry--) {
-        const [attributeName, attributeValue] = scriptTagEntries[currentScriptTagEntry];
-        newTag.querySelector("script").setAttribute(attributeName, attributeValue);
-      }
-      headTag.appendChild(newTag);
-    }
-  }
-  if (head.jsonld) {
-    const newTag = htmlParser.parse(`<script><\/script>`);
-    const tag = newTag.querySelector("script");
-    tag.setAttribute("type", "application/ld+json");
-    tag.set_content(JSON.stringify(head.jsonld, null, 2));
-    headTag.appendChild(newTag);
-  }
-  return html.toString();
-};
-export {
-  setHeadTagsInHTML_default as default
-};

package/dist/validation/index.js

@@ -1,10 +0,0 @@
-import schema from "./schema/index.js";
-import inputWithSchema from "./inputWithSchema/index.js";
-const validate = {
-  schema,
-  inputWithSchema
-};
-var validation_default = validate;
-export {
-  validation_default as default
-};

package/dist/validation/index.test.js

@@ -1,463 +0,0 @@
-import validate from "./index";
-import { handleGetInputValue, getArrayPathKey, addToValidationQueue } from "./inputWithSchema";
-describe("validate/schema/index.js", () => {
-  test("throws error if schema argument is not passed", () => {
-    expect(() => {
-      validate.schema();
-    }).toThrow("[joystick.validation] Must pass schema object.");
-  });
-  test("throws error if schema argument is invalid type", () => {
-    expect(() => {
-      validate.schema(1);
-    }).toThrow("[joystick.validation] Must pass schema as an object.");
-  });
-  test("throws error if schema object contains properties with values that are not objects", () => {
-    expect(() => {
-      validate.schema({
-        _id: {
-          type: "string"
-        },
-        userId: false,
-        title: {
-          type: "string"
-        }
-      });
-    }).toThrow(`Must pass an object containing rules to validate by for userId field.`);
-  });
-  test("throws error if schema field rule names are unsupported", () => {
-    expect(() => {
-      validate.schema({
-        _id: {
-          type: "string",
-          allowedValues: "",
-          element: "",
-          fields: "",
-          max: "",
-          min: "",
-          optional: "",
-          required: "",
-          hotDog: ""
-        },
-        userId: {},
-        title: {
-          type: "string"
-        }
-      });
-    }).toThrow(`Invalid rule name hotDog in rule for _id field.`);
-  });
-  test("throws error if schema field rule.type value is unsupported", () => {
-    expect(() => {
-      validate.schema({
-        _id: {
-          type: "apples"
-        }
-      });
-    }).toThrow(`Invalid value for schema field "_id" type rule. apples is not supported. Use one of the following: any, array, boolean, float, integer, number, object, or string.`);
-  });
-});
-describe("validate/inputWithSchema/index.js", () => {
-  test("does not throw if process.env.NODE_ENV equals test", () => {
-    expect(async () => {
-      process.env.NODE_ENV = "test";
-      const result = await validate.inputWithSchema({}, {});
-    }).not.toThrow();
-  });
-  test("does not throw if process.env.NODE_ENV does not equal test", () => {
-    expect(async () => {
-      process.env.NODE_ENV = "production";
-      const result = await validate.inputWithSchema({}, {});
-    }).not.toThrow();
-  });
-  test("throws error if input argument is not passed", () => {
-    expect(async () => {
-      const result = await validate.inputWithSchema();
-    }).rejects.toThrow("[joystick.validation] Must pass input.");
-  });
-  test("addToValidationQueue throws error if queue argument is not an array", () => {
-    expect(() => {
-      addToValidationQueue(3);
-    }).toThrow("queue must be an array");
-  });
-  test("handleGetInputValue throws error if path argument is not a string", () => {
-    expect(() => {
-      handleGetInputValue(null, 3, false);
-    }).toThrow("path must be passed as a string");
-  });
-  test("getArrayPathKey returns a string with the name of they key", () => {
-    const arrayPathKey = getArrayPathKey("this.is.the.thing");
-    expect(arrayPathKey).toEqual("thing");
-  });
-  test("getArrayPathKey returns a string if arrayPath is undefined", () => {
-    const arrayPathKey = getArrayPathKey();
-    expect(arrayPathKey).toEqual("");
-  });
-  test("getArrayPathKey throws error if arrayPath argument is not a string", () => {
-    expect(() => {
-      getArrayPathKey(5);
-    }).toThrow("arrayPath must be a type of string");
-  });
-  test("returns expected errors when rules.allowedValues validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: "apples"
-    }, {
-      name: {
-        type: "string",
-        allowedValues: ["buy", "more", "bitcoin"]
-      }
-    });
-    expect(errors).toEqual([
-      "Field name only allows the following values: buy, more, bitcoin."
-    ]);
-  });
-  test("returns expected errors when nested rules.allowedValues validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: "apples",
-      dog: [
-        {
-          breed: "Corgi"
-        },
-        {
-          breed: "German Shepherd",
-          coats: [{ type: "rough" }]
-        },
-        {
-          breed: "English Bulldog"
-        }
-      ]
-    }, {
-      name: {
-        type: "string",
-        allowedValues: ["buy", "more", "bitcoin"]
-      },
-      dog: {
-        type: "array",
-        element: {
-          breed: {
-            type: "string",
-            allowedValues: ["Corgi", "German Shepherd", "Golden Retriever"]
-          },
-          coats: {
-            type: "array",
-            element: {
-              style: {
-                type: "string",
-                allowedValues: ["silky", "dry", "smooth"]
-              }
-            }
-          }
-        }
-      }
-    });
-    expect(errors).toEqual([
-      "Field name only allows the following values: buy, more, bitcoin.",
-      "Field dog.1.coats.0.style only allows the following values: silky, dry, smooth.",
-      "Field dog.2.breed only allows the following values: Corgi, German Shepherd, Golden Retriever."
-    ]);
-  });
-  test("returns expected errors when rules.element (string) validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      birds: [1, 2, 3]
-    }, {
-      birds: {
-        type: "array",
-        element: "string"
-      }
-    });
-    expect(errors).toEqual([
-      "Field birds.0 must be of type string.",
-      "Field birds.1 must be of type string.",
-      "Field birds.2 must be of type string."
-    ]);
-  });
-  test("returns expected errors when nested rules.element (string) validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      birds: [
-        {
-          name: "Parrot",
-          attributes: {
-            colors: ["blue", "green", "red"]
-          }
-        },
-        {
-          name: "Snake",
-          attributes: {
-            colors: ["purple", "orange", "teal"]
-          }
-        }
-      ]
-    }, {
-      birds: {
-        type: "array",
-        element: {
-          name: {
-            type: "string"
-          },
-          attributes: {
-            type: "object",
-            fields: {
-              colors: {
-                type: "array",
-                element: "integer"
-              }
-            }
-          }
-        }
-      }
-    });
-    expect(errors).toEqual([
-      "Field birds.0.attributes.colors.0 must be of type integer.",
-      "Field birds.0.attributes.colors.1 must be of type integer.",
-      "Field birds.0.attributes.colors.2 must be of type integer.",
-      "Field birds.1.attributes.colors.0 must be of type integer.",
-      "Field birds.1.attributes.colors.1 must be of type integer.",
-      "Field birds.1.attributes.colors.2 must be of type integer."
-    ]);
-  });
-  test("returns expected errors when rules.fields validator is passed value other than object", async () => {
-    const errors = await validate.inputWithSchema({
-      user: {
-        name: 789.456
-      }
-    }, {
-      user: {
-        type: "object",
-        fields: "no bueno"
-      }
-    });
-    expect(errors).toEqual(["Field user schema rule and input value for element must be of type object."]);
-  });
-  test("returns expected errors when rules.fields validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      user: {
-        name: 789.456
-      }
-    }, {
-      user: {
-        type: "object",
-        fields: {
-          name: {
-            type: "string"
-          }
-        }
-      }
-    });
-    expect(errors).toEqual(["Field user.name must be of type string."]);
-  });
-  test("returns expected errors when rules.max validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 39.99
-    }, {
-      price: {
-        type: "float",
-        max: 29.99
-      }
-    });
-    expect(errors).toEqual([
-      "Field price must be less than or equal to 29.99."
-    ]);
-  });
-  test("returns no errors when rules.max validator returns valid true", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 39.99
-    }, {
-      price: {
-        type: "float",
-        max: 39.99
-      }
-    });
-    expect(errors).toEqual([]);
-  });
-  test("returns expected errors when rules.min validator fails", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 19.99
-    }, {
-      price: {
-        type: "float",
-        min: 29.99
-      }
-    });
-    expect(errors).toEqual([
-      "Field price must be greater than or equal to 29.99."
-    ]);
-  });
-  test("returns expected errors when rules.optional (false) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 29.99
-    }, {
-      price: {
-        type: "float",
-        min: 29.99
-      },
-      description: {
-        type: "string",
-        optional: false
-      }
-    });
-    expect(errors).toEqual(["Field description is required."]);
-  });
-  test("returns no errors when rules.optional (true)", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 29.99
-    }, {
-      price: {
-        type: "float",
-        min: 29.99
-      },
-      description: {
-        type: "string",
-        optional: true
-      }
-    });
-    expect(errors).toEqual([]);
-  });
-  test("returns expected errors when rules.regex fails", async () => {
-    const errors = await validate.inputWithSchema({
-      arrayPath: "thing.is.not.in.array"
-    }, {
-      arrayPath: {
-        type: "string",
-        regex: new RegExp(/\.[0-9]+\.?/g)
-      }
-    });
-    expect(errors).toEqual([
-      "Field arrayPath must conform to regex: /\\.[0-9]+\\.?/g."
-    ]);
-  });
-  test("returns no errors when rules.regex returns valid true", async () => {
-    const errors = await validate.inputWithSchema({
-      arrayPath: ".0."
-    }, {
-      arrayPath: {
-        type: "string",
-        regex: new RegExp(/\.[0-9]+\.?/g)
-      }
-    });
-    expect(errors).toEqual([]);
-  });
-  test("returns expected errors when rules.required (true) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 29.99
-    }, {
-      price: {
-        type: "float",
-        min: 29.99
-      },
-      description: {
-        type: "string",
-        required: true
-      }
-    });
-    expect(errors).toEqual(["Field description is required."]);
-  });
-  test("returns no errors when rules.required (false)", async () => {
-    const errors = await validate.inputWithSchema({
-      price: 29.99
-    }, {
-      price: {
-        type: "float",
-        min: 29.99
-      },
-      description: {
-        type: "string",
-        required: false
-      }
-    });
-    expect(errors).toEqual([]);
-  });
-  test("returns expected errors when rules.type (array) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: "array"
-    }, {
-      name: {
-        type: "array"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type array."]);
-  });
-  test("returns expected errors when rules.type (boolean) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: 123
-    }, {
-      name: {
-        type: "boolean"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type boolean."]);
-  });
-  test("returns expected errors when rules.type (float) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: 123
-    }, {
-      name: {
-        type: "float"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type float."]);
-  });
-  test("returns expected errors when rules.type (integer) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: 123.123
-    }, {
-      name: {
-        type: "integer"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type integer."]);
-  });
-  test("returns expected errors when rules.type (number) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: "123.123"
-    }, {
-      name: {
-        type: "number"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type number."]);
-  });
-  test("returns expected errors when rules.type (object) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: []
-    }, {
-      name: {
-        type: "object"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type object."]);
-  });
-  test("returns expected errors when rules.type (string) fails", async () => {
-    const errors = await validate.inputWithSchema({
-      name: 123
-    }, {
-      name: {
-        type: "string"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type string."]);
-  });
-  test("returns no errors when rules.type (any) is passed", async () => {
-    const errors = await validate.inputWithSchema({
-      name: 123
-    }, {
-      name: {
-        type: "any"
-      }
-    });
-    expect(errors).toEqual([]);
-  });
-  test("returns array of errors after validation", async () => {
-    const errors = await validate.inputWithSchema({
-      name: 12345
-    }, {
-      name: {
-        type: "string"
-      }
-    });
-    expect(errors).toEqual(["Field name must be of type string."]);
-  });
-  test("throws error if file at path for dynamic require of inputWithSchema does not exist", () => {
-  });
-  test("throws error if file dynamically required for inputWithSchema returns an object without a default property", () => {
-  });
-  test("returns valid true if inputWithSchema cannot be dynamically required", () => {
-  });
-});

package/dist/validation/inputWithSchema/index.js

@@ -1,105 +0,0 @@
-import throwError from "../lib/throwError";
-import validateSchema from "../schema/index";
-import { isObject, isString } from "../lib/typeValidators";
-import isArrayPath from "../lib/isArrayPath";
-import getValueFromObject from "../lib/getValueFromObject";
-import constants from "../lib/constants";
-const handleGetInputValue = (input = null, path = "", rulesOnlySchema = false) => {
-  if (path && !isString(path)) {
-    throw new Error("path must be passed as a string");
-  }
-  if (rulesOnlySchema || !rulesOnlySchema && !isObject(input)) {
-    return input;
-  }
-  if (path.includes(".$.")) {
-    const [arrayPath] = path.split(".$.");
-    return getValueFromObject(input, arrayPath);
-  }
-  return getValueFromObject(input, path);
-};
-const getArrayPathKey = (arrayPath = "") => {
-  if (!arrayPath) {
-    return "";
-  }
-  if (arrayPath && !isString(arrayPath)) {
-    throw new Error("arrayPath must be a type of string");
-  }
-  const arrayPathParts = arrayPath.split(".");
-  return arrayPathParts.pop();
-};
-const addValidationTask = ({ queue, rules, input, path, rulesOnlySchema }) => {
-  if (rules && rules.type === "object") {
-    queue = addToValidationQueue(queue, rules.properties, input, path);
-  }
-  if (rules && rules.type === "array" && isObject(rules.element)) {
-    queue = addToValidationQueue(queue, rules.element, input, `${path}.$`);
-  }
-  const pathToValue = isArrayPath(path) ? getArrayPathKey(path) : path;
-  return {
-    path,
-    rules,
-    inputValue: handleGetInputValue(input, pathToValue, rulesOnlySchema)
-  };
-};
-const addToValidationQueue = (queue = [], schema = {}, input = {}, parentPath = "") => {
-  if (queue && !Array.isArray(queue)) {
-    throw new Error("queue must be an array");
-  }
-  const rulesOnlySchema = !!(schema.type && constants.types.includes(schema.type));
-  if (!rulesOnlySchema) {
-    Object.entries(schema).forEach(([field, rules]) => {
-      const path = `${parentPath ? `${parentPath}.${field}` : field}`;
-      const validationTask = addValidationTask({
-        queue,
-        rules,
-        input,
-        path,
-        rulesOnlySchema
-      });
-      queue = [...queue, validationTask];
-    });
-  }
-  if (rulesOnlySchema) {
-    const path = parentPath;
-    const validationTask = addValidationTask({
-      queue,
-      rules: schema,
-      input,
-      path,
-      rulesOnlySchema
-    });
-    queue = [...queue, validationTask];
-  }
-  return queue;
-};
-const validateInputWithSchema = async (input = null, schema = null, parentPath = "") => {
-  const errors = [];
-  if (!input) {
-    errors.push("Input is required.");
-  }
-  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]) => {
-      const validator = constants.rules[ruleName];
-      if (validator && !validationTask.path.includes(".$.")) {
-        const result = await validator(ruleValue, validationTask.inputValue, validationTask.path);
-        if (result && !result.valid) {
-          return result.errors.forEach((error) => {
-            return errors.push(error);
-          });
-        }
-      }
-    });
-  }));
-  return errors;
-};
-var inputWithSchema_default = validateInputWithSchema;
-export {
-  addToValidationQueue,
-  inputWithSchema_default as default,
-  getArrayPathKey,
-  handleGetInputValue
-};