schema-shield 0.0.2 → 0.0.3

package/lib/types.ts

@@ -1,176 +1,49 @@
-import { ValidationError } from "./utils";
-import { ValidatorFunction } from "./index";
+import { TypeFunction } from "./index";
+import { isObject } from "./utils";
 
-export const Types: Record<string, ValidatorFunction> = {
-  object(schema, data, pointer) {
-    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not an object", {
-          pointer,
-          value: data,
-          code: "NOT_AN_OBJECT"
-        })
-      ],
-      data
-    };
+export const Types: Record<string, TypeFunction | false> = {
+  object(data) {
+    return isObject(data);
   },
-  array(schema, data, pointer) {
+  array(data) {
     if (Array.isArray(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-
-    if (typeof data === "object" && data !== null && "length" in data) {
-      // Check if the first key is a number and the length is the same as the number of keys - 1 (length)
-      const keys = Object.keys(data);
-      if (keys.length > 0 && (keys[0] !== "0" || keys.length !== data.length)) {
-        return {
-          valid: false,
-          errors: [
-            new ValidationError("Data is not an array", {
-              pointer,
-              value: data,
-              code: "NOT_AN_ARRAY"
-            })
-          ],
-          data
-        };
-      }
-
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
+      return true;
     }
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not an array", {
-          pointer,
-          value: data,
-          code: "NOT_AN_ARRAY"
-        })
-      ],
-      data
-    };
+    return (
+      typeof data === "object" &&
+      data !== null &&
+      "length" in data &&
+      "0" in data &&
+      Object.keys(data).length - 1 === data.length
+    );
   },
-  string(schema, data, pointer) {
-    if (typeof data === "string") {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not a string", {
-          pointer,
-          value: data,
-          code: "NOT_A_STRING"
-        })
-      ],
-      data
-    };
+  string(data) {
+    return typeof data === "string";
   },
-  number(schema, data, pointer) {
-    if (typeof data === "number") {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not a number", {
-          pointer,
-          value: data,
-          code: "NOT_A_NUMBER"
-        })
-      ],
-      data
-    };
+  number(data) {
+    return typeof data === "number";
   },
-  integer(schema, data, pointer) {
-    if (typeof data === "number" && Number.isInteger(data)) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not an integer", {
-          pointer,
-          value: data,
-          code: "NOT_AN_INTEGER"
-        })
-      ],
-      data
-    };
+  integer(data) {
+    return typeof data === "number" && data % 1 === 0;
   },
-  boolean(schema, data, pointer) {
-    if (typeof data === "boolean") {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not a boolean", {
-          pointer,
-          value: data,
-          code: "NOT_A_BOOLEAN"
-        })
-      ],
-      data
-    };
+  boolean(data) {
+    return typeof data === "boolean";
   },
-  null(schema, data, pointer) {
-    if (data === null) {
-      return {
-        valid: true,
-        errors: [],
-        data
-      };
-    }
+  null(data) {
+    return data === null;
+  },
+
+  // Not implemented yet
+  timestamp: false,
+  int8: false,
+  unit8: false,
+  int16: false,
+  unit16: false,
+  int32: false,
+  unit32: false,
+  float32: false,
+  float64: false
+
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Data is not null", {
-          pointer,
-          value: data,
-          code: "NOT_NULL"
-        })
-      ],
-      data
-    };
-  }
 };

package/lib/utils.ts

@@ -1,38 +1,65 @@
-import { SchemaShield, ValidationErrorProps } from "./index";
+import { CompiledSchema } from "./index";
 
 export class ValidationError extends Error {
-  name: string;
-  pointer: string;
   message: string;
-  value: any;
-  code: string;
-
-  constructor(
-    message: string,
-    options: ValidationErrorProps = {
-      pointer: "",
-      value: null,
-      code: ""
+  item: string | number;
+  keyword: string;
+  cause: ValidationError;
+  path: string = "";
+  data?: any;
+  schema?: CompiledSchema;
+
+  private _getCause(pointer = "#") {
+    const path =
+      pointer +
+      "/" +
+      this.keyword +
+      (typeof this.item !== "undefined" ? "/" + this.item : "");
+
+    if (!this.cause) {
+      this.path = path;
+      return this;
     }
-  ) {
-    super(message);
-    this.name = "ValidationError";
-    this.pointer = options.pointer;
-    this.message = message;
-    this.value = options.value;
-    this.code = options.code;
+
+    return this.cause._getCause(path);
+  }
+
+  getCause() {
+    return this._getCause();
   }
 }
 
-export const defaultValidator = (schema, data, pointer) => {
-  return [
-    new ValidationError("No validator for this schema", {
-      pointer,
-      value: data,
-      code: "NO_VALIDATOR"
-    })
-  ];
-};
+export interface DefineErrorOptions {
+  item?: any; // Final item in the path
+  cause?: ValidationError; // Cause of the error
+  data?: any; // Data that caused the error
+}
+
+export interface DefineErrorFunction {
+  (message: string, options?: DefineErrorOptions): ValidationError;
+}
+
+export function getDefinedErrorFunctionForKey(
+  key: string,
+  schema: CompiledSchema
+) {
+  const KeywordError = new ValidationError(`Invalid ${key}`);
+  KeywordError.keyword = key;
+  KeywordError.schema = schema;
+
+  const defineError: DefineErrorFunction = (message, options = {}) => {
+    KeywordError.message = message;
+    KeywordError.item = options.item;
+    KeywordError.cause = options.cause;
+    KeywordError.data = options.data;
+    return KeywordError;
+  };
+
+  return getNamedFunction<DefineErrorFunction>(
+    `defineError_${key}`,
+    defineError
+  );
+}
 
 export function deepEqual(
   obj: Array<any> | Record<string, any>,
@@ -77,3 +104,54 @@ export function deepEqual(
 export function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
+
+export function areCloseEnough(a, b, epsilon = 1e-15) {
+  return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
+}
+
+export function getUTF16Length(str) {
+  let length = 0;
+  for (let i = 0; i < str.length; i++) {
+    const codePoint = str.codePointAt(i);
+    if (codePoint > 0xffff) {
+      i++;
+    }
+    length++;
+  }
+  return length;
+}
+
+export function deepClone(obj: any): any {
+  if (Array.isArray(obj)) {
+    const result = [];
+    for (let i = 0; i < obj.length; i++) {
+      result[i] = deepClone(obj[i]);
+    }
+    return result;
+  }
+
+  // Is class instance of any kind
+  if (obj && obj.constructor && obj.constructor.name !== "Object") {
+    return obj;
+  }
+
+  if (isObject(obj)) {
+    const result = {
+      ...obj
+    };
+    for (const key in obj) {
+      result[key] = deepClone(obj[key]);
+    }
+    return result;
+  }
+
+  return obj;
+}
+
+export function isCompiledSchema(subSchema: any): subSchema is CompiledSchema {
+  return isObject(subSchema) && "$validate" in subSchema;
+}
+
+export function getNamedFunction<T>(name: string, fn: T): T {
+  return Object.defineProperty(fn, "name", { value: name });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-shield",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A fast library that protects your JSON schema from invalid data.",
   "repository": "git@github.com:Masquerade-Circus/schema-shield.git",
   "author": "Masquerade <christian@masquerade-circus.net>",
@@ -69,7 +69,7 @@
     "node": ">=12.0.0"
   },
   "scripts": {
-    "test": "mocha --bail --recursive --no-timeouts --exit --require ts-node/register --enable-source-maps tests/**/*.test.ts",
+    "test": "mocha --bail --recursive --no-timeouts  --forbid-only --exit --require ts-node/register --enable-source-maps tests/**/*.test.ts",
     "dev:test": "nodemon -e ts,js -w ./tests -w ./lib --exec npm run test",
     "dev:source": "NODE_ENV=development nodemon --enable-source-maps -e tsx,ts,json,css -w ./lib -w ./www source.js",
     "build": "node source.js",
@@ -79,6 +79,7 @@
     "release-test": "release-it --dry-run --verbose"
   },
   "dependencies": {
+    "is-my-ip-valid": "^1.0.1",
     "ts-node": "^10.9.1",
     "tsc-prog": "^2.2.1",
     "tslib": "^2.5.0",