schema-shield 0.0.2

package/lib/keywords.ts

@@ -0,0 +1,14 @@
+import { ArrayKeywords } from "./keywords/array-keywords";
+import { NumberKeywords } from "./keywords/number-keywords";
+import { ObjectKeywords } from "./keywords/object-keywords";
+import { OtherKeywords } from "./keywords/other-keywords";
+import { StringKeywords } from "./keywords/string-keywords";
+import { ValidatorFunction } from "./index";
+
+export const keywords: Record<string, ValidatorFunction> = {
+  ...ObjectKeywords,
+  ...ArrayKeywords,
+  ...StringKeywords,
+  ...NumberKeywords,
+  ...OtherKeywords
+};

package/lib/types.ts

@@ -0,0 +1,176 @@
+import { ValidationError } from "./utils";
+import { ValidatorFunction } from "./index";
+
+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
+    };
+  },
+  array(schema, data, pointer) {
+    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 {
+      valid: false,
+      errors: [
+        new ValidationError("Data is not an array", {
+          pointer,
+          value: data,
+          code: "NOT_AN_ARRAY"
+        })
+      ],
+      data
+    };
+  },
+  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
+    };
+  },
+  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
+    };
+  },
+  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
+    };
+  },
+  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
+    };
+  },
+  null(schema, data, pointer) {
+    if (data === null) {
+      return {
+        valid: true,
+        errors: [],
+        data
+      };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("Data is not null", {
+          pointer,
+          value: data,
+          code: "NOT_NULL"
+        })
+      ],
+      data
+    };
+  }
+};

package/lib/utils.ts

@@ -0,0 +1,79 @@
+import { SchemaShield, ValidationErrorProps } 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: ""
+    }
+  ) {
+    super(message);
+    this.name = "ValidationError";
+    this.pointer = options.pointer;
+    this.message = message;
+    this.value = options.value;
+    this.code = options.code;
+  }
+}
+
+export const defaultValidator = (schema, data, pointer) => {
+  return [
+    new ValidationError("No validator for this schema", {
+      pointer,
+      value: data,
+      code: "NO_VALIDATOR"
+    })
+  ];
+};
+
+export function deepEqual(
+  obj: Array<any> | Record<string, any>,
+  other: Array<any> | Record<string, any>
+) {
+  if (Array.isArray(obj) && Array.isArray(other)) {
+    if (obj.length !== other.length) {
+      return false;
+    }
+
+    for (let i = 0; i < obj.length; i++) {
+      if (!deepEqual(obj[i], other[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  if (typeof obj === "object" && typeof other === "object") {
+    if (obj === null || other === null) {
+      return obj === other;
+    }
+
+    const keys = Object.keys(obj);
+    if (keys.length !== Object.keys(other).length) {
+      return false;
+    }
+
+    for (const key of keys) {
+      if (!deepEqual(obj[key], other[key])) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  return obj === other;
+}
+
+export function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}

package/package.json

@@ -0,0 +1,189 @@
+{
+  "name": "schema-shield",
+  "version": "0.0.2",
+  "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>",
+  "funding": "https://github.com/sponsors/Masquerade-Circus",
+  "license": "Apache-2.0",
+  "private": false,
+  "sideEffects": false,
+  "source": "lib/index.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "unpkg": "dist/index.min.js",
+  "browser": "dist/index.min.js",
+  "types": "dist/**/*.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*/index.mjs",
+      "require": "./dist/*/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "lib",
+    "package-lock.json",
+    "LICENSE",
+    "tsconfig.json"
+  ],
+  "keywords": [
+    "Schema Shield",
+    "JSON",
+    "JSON Schema",
+    "Validation",
+    "Validator",
+    "Validate",
+    "Data",
+    "Object",
+    "Node.js",
+    "Web",
+    "TypeScript",
+    "Schema",
+    "Shield",
+    "Protection",
+    "Constraints",
+    "Compliance",
+    "Integrity",
+    "Accuracy",
+    "Efficiency",
+    "Performance",
+    "Lightweight",
+    "Extensible",
+    "Reliable",
+    "Error free",
+    "Fast",
+    "Robust",
+    "Precise",
+    "Secure",
+    "Easy to use",
+    "User friendly"
+  ],
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "scripts": {
+    "test": "mocha --bail --recursive --no-timeouts --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",
+    "coverage": "nyc report --reporter=lcov",
+    "commit": "git add . && git-cz",
+    "release": "release-it --verbose",
+    "release-test": "release-it --dry-run --verbose"
+  },
+  "dependencies": {
+    "ts-node": "^10.9.1",
+    "tsc-prog": "^2.2.1",
+    "tslib": "^2.5.0",
+    "typescript": "^5.0.2"
+  },
+  "devDependencies": {
+    "@release-it/conventional-changelog": "^5.1.1",
+    "@typescript-eslint/eslint-plugin": "^5.56.0",
+    "@typescript-eslint/parser": "^5.56.0",
+    "cz-conventional-changelog": "^3.3.0",
+    "esbuild": "^0.17.12",
+    "eslint": "^8.36.0",
+    "eslint-plugin-sonarjs": "^0.19.0",
+    "expect": "^29.5.0",
+    "json-schema-test-suite": "github:json-schema-org/JSON-Schema-Test-Suite",
+    "mocha": "^10.2.0",
+    "nodemon": "^2.0.22",
+    "nyc": "^15.1.0",
+    "release-it": "^15.9.3",
+    "terser": "^5.16.6"
+  },
+  "nyc": {
+    "exclude": [
+      "test",
+      "register.js"
+    ]
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "release-it": {
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "infile": "CHANGELOG.md",
+        "preset": {
+          "name": "conventionalcommits",
+          "types": [
+            {
+              "type": "feat",
+              "section": "Features"
+            },
+            {
+              "type": "feature",
+              "section": "Features"
+            },
+            {
+              "type": "fix",
+              "section": "Bug Fixes"
+            },
+            {
+              "type": "perf",
+              "section": "Performance Improvements"
+            },
+            {
+              "type": "revert",
+              "section": "Reverts"
+            },
+            {
+              "type": "docs",
+              "section": "Documentation"
+            },
+            {
+              "type": "style",
+              "section": "Styles"
+            },
+            {
+              "type": "chore",
+              "section": "Miscellaneous Chores"
+            },
+            {
+              "type": "refactor",
+              "section": "Code Refactoring"
+            },
+            {
+              "type": "test",
+              "section": "Tests"
+            },
+            {
+              "type": "build",
+              "section": "Build System"
+            },
+            {
+              "type": "ci",
+              "section": "Continuous Integration"
+            }
+          ]
+        }
+      }
+    },
+    "git": {
+      "requireCleanWorkingDir": false
+    },
+    "github": {
+      "release": true
+    },
+    "npm": {
+      "publish": true
+    },
+    "hooks": {
+      "before:init": [
+        "npm run build",
+        "npm run test"
+      ]
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "target": "ES2021",
+    "moduleResolution": "nodenext",
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "allowJs": true,
+    "esModuleInterop": true
+  },
+  "include": ["lib/**/*"],
+  "exclude": ["**/*.spec.ts", "node_modules/**/*", "docs/**/*"],
+  "ts-node": {
+    "transpileOnly": true
+  }
+}