schema-shield 0.0.2

package/dist/keywords/array-keywords.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "../index";
+export declare const ArrayKeywords: Record<string, ValidatorFunction>;
+//# sourceMappingURL=array-keywords.d.ts.map

package/dist/keywords/array-keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-keywords.d.ts","sourceRoot":"","sources":["../../lib/keywords/array-keywords.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAwM3D,CAAC"}

package/dist/keywords/number-keywords.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "../index";
+export declare const NumberKeywords: Record<string, ValidatorFunction>;
+//# sourceMappingURL=number-keywords.d.ts.map

package/dist/keywords/number-keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-keywords.d.ts","sourceRoot":"","sources":["../../lib/keywords/number-keywords.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CA2E5D,CAAC"}

package/dist/keywords/object-keywords.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "../index";
+export declare const ObjectKeywords: Record<string, ValidatorFunction>;
+//# sourceMappingURL=object-keywords.d.ts.map

package/dist/keywords/object-keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-keywords.d.ts","sourceRoot":"","sources":["../../lib/keywords/object-keywords.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7D,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAkO5D,CAAC"}

package/dist/keywords/other-keywords.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "../index";
+export declare const OtherKeywords: Record<string, ValidatorFunction>;
+//# sourceMappingURL=other-keywords.d.ts.map

package/dist/keywords/other-keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"other-keywords.d.ts","sourceRoot":"","sources":["../../lib/keywords/other-keywords.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAoP3D,CAAC"}

package/dist/keywords/string-keywords.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "../index";
+export declare const StringKeywords: Record<string, ValidatorFunction>;
+//# sourceMappingURL=string-keywords.d.ts.map

package/dist/keywords/string-keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-keywords.d.ts","sourceRoot":"","sources":["../../lib/keywords/string-keywords.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAgK5D,CAAC"}

package/dist/keywords.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "./index";
+export declare const keywords: Record<string, ValidatorFunction>;
+//# sourceMappingURL=keywords.d.ts.map

package/dist/keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../lib/keywords.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAMtD,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFunction } from "./index";
+export declare const Types: Record<string, ValidatorFunction>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CA4KnD,CAAC"}

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+import { ValidationErrorProps } from "./index";
+export declare class ValidationError extends Error {
+    name: string;
+    pointer: string;
+    message: string;
+    value: any;
+    code: string;
+    constructor(message: string, options?: ValidationErrorProps);
+}
+export declare const defaultValidator: (schema: any, data: any, pointer: any) => ValidationError[];
+export declare function deepEqual(obj: Array<any> | Record<string, any>, other: Array<any> | Record<string, any>): boolean;
+export declare function isObject(data: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE7D,qBAAa,eAAgB,SAAQ,KAAK;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;gBAGX,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAIR;CASJ;AAED,eAAO,MAAM,gBAAgB,6DAQ5B,CAAC;AAEF,wBAAgB,SAAS,CACvB,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,WAoCxC;AAED,wBAAgB,QAAQ,CAAC,IAAI,KAAA,WAE5B"}

package/lib/formats.ts

@@ -0,0 +1,56 @@
+import { FormatFunction, ValidationError, ValidatorFunction } from "./utils";
+
+const RegExps = {
+  "date-time":
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/,
+  uri: /^[a-zA-Z][a-zA-Z0-9+\-.]*:[^\s]*$/,
+  email:
+    /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+  ipv6: /^(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?=(?:[0-9a-fA-F]{0,4}:){0,7}[0-9a-fA-F]{0,4}(?![:.\w]))(([0-9a-fA-F]{1,4}:){1,7}|:)((:[0-9a-fA-F]{1,4}){1,7}|:))$/,
+  hostname: /^[a-zA-Z0-9][a-zA-Z0-9-]{0,62}(\.[a-zA-Z0-9][a-zA-Z0-9-]{0,62})*$/
+};
+
+function notImplementedFormat(data: any) {
+  throw new ValidationError(
+    `Format "${data}" is not implemented yet. Please open an issue on GitHub.`
+  );
+
+  return false;
+}
+
+export const Formats: Record<string, FormatFunction> = {
+  ["date-time"](data) {
+    return RegExps["date-time"].test(data);
+  },
+  uri(data) {
+    return RegExps.uri.test(data);
+  },
+  email(data) {
+    return RegExps.email.test(data);
+  },
+  ipv4(data) {
+    return RegExps.ipv4.test(data);
+  },
+  ipv6(data) {
+    return RegExps.ipv6.test(data);
+  },
+  hostname(data) {
+    return RegExps.hostname.test(data);
+  },
+
+  // Not supported yet
+  time: notImplementedFormat,
+  date: notImplementedFormat,
+  duration: notImplementedFormat,
+  "idn-email": notImplementedFormat,
+  "idn-hostname": notImplementedFormat,
+  uuid: notImplementedFormat,
+  "uri-reference": notImplementedFormat,
+  iri: notImplementedFormat,
+  "iri-reference": notImplementedFormat,
+  "uri-template": notImplementedFormat,
+  "json-pointer": notImplementedFormat,
+  "relative-json-pointer": notImplementedFormat,
+  regex: notImplementedFormat
+};

package/lib/index.ts

@@ -0,0 +1,308 @@
+import { ValidationError, isObject } from "./utils";
+
+import { Formats } from "./formats";
+import { Types } from "./types";
+import { keywords } from "./keywords";
+
+export interface ValidationErrorProps {
+  pointer: string;
+  value: any;
+  code: string;
+}
+
+export interface Result {
+  valid: boolean;
+  errors: ValidationError[];
+  data: any;
+}
+
+export interface ValidatorFunction {
+  (
+    schema: CompiledSchema,
+    data: any,
+    pointer: string,
+    schemaShieldInstance: SchemaShield
+  ): Result;
+}
+
+export interface FormatFunction {
+  (data: any): boolean;
+}
+
+export interface CompiledSchema {
+  pointer: string;
+  validator?: ValidatorFunction;
+  type?: string;
+  validators?: ValidatorFunction[];
+  keywords?: Record<string, ValidatorFunction>;
+  [key: string]: any;
+}
+
+export interface Validator {
+  (data: any): Result;
+  compiledSchema: CompiledSchema;
+}
+
+export class SchemaShield {
+  types = new Map<string, ValidatorFunction>();
+  formats = new Map<string, FormatFunction>();
+  keywords = new Map<string, ValidatorFunction>();
+
+  constructor() {
+    for (const type in Types) {
+      this.addType(type, Types[type]);
+    }
+
+    for (const keyword in keywords) {
+      this.addKeyword(keyword, keywords[keyword]);
+    }
+
+    for (const format in Formats) {
+      this.addFormat(format, Formats[format]);
+    }
+  }
+
+  addType(name: string, validator: ValidatorFunction) {
+    this.types.set(name, validator);
+  }
+
+  addFormat(name: string, validator: FormatFunction) {
+    this.formats.set(name, validator);
+  }
+
+  addKeyword(name: string, validator: ValidatorFunction) {
+    this.keywords.set(name, validator);
+  }
+
+  compile(schema: any): Validator {
+    const compiledSchema = this.compileSchema(schema, "#");
+    const schemaShield = this;
+
+    function validate(data: any) {
+      return compiledSchema.validator(compiledSchema, data, "#", schemaShield);
+    }
+
+    validate.compiledSchema = compiledSchema;
+
+    return validate;
+  }
+
+  private compileSchema(
+    schema: Partial<CompiledSchema>,
+    pointer
+  ): CompiledSchema {
+    if (typeof schema !== "object" || schema === null) {
+      throw new ValidationError("Schema is not an object", {
+        pointer,
+        value: schema,
+        code: "SCHEMA_NOT_OBJECT"
+      });
+    }
+
+    const compiledSchema = {
+      ...schema,
+      pointer
+    };
+
+    if ("type" in compiledSchema) {
+      const types = Array.isArray(compiledSchema.type)
+        ? compiledSchema.type
+        : compiledSchema.type.split(",").map((t) => t.trim());
+
+      compiledSchema.validators = types
+        .filter((type) => this.types.has(type))
+        .map((type) => this.types.get(type));
+    }
+
+    // Compile schema type
+    const validator: ValidatorFunction = (
+      schema: any,
+      data: any,
+      pointer: string
+    ) => {
+      if (typeof data === "undefined") {
+        if (pointer === "#") {
+          return {
+            valid: false,
+            errors: [
+              new ValidationError("Data is undefined", {
+                pointer,
+                value: data,
+                code: "DATA_UNDEFINED"
+              })
+            ],
+            data
+          };
+        }
+      }
+
+      let finalData = data;
+      const typeErrorsResult = this.validateTypes(schema, finalData, pointer);
+      if (typeErrorsResult.valid === false) {
+        return typeErrorsResult;
+      }
+      finalData = typeErrorsResult.data;
+
+      return this.validateKeywords(schema, finalData, pointer);
+    };
+
+    compiledSchema.validator = validator;
+
+    // Recursively compile sub schemas
+    for (let key in schema) {
+      // Skip type as it is already compiled
+      if (key === "type") {
+        continue;
+      }
+
+      if (this.keywords.has(key)) {
+        const validator = this.keywords.get(key);
+        compiledSchema.keywords = compiledSchema.keywords || {};
+        compiledSchema.keywords[key] = validator;
+      }
+
+      if (Array.isArray(schema[key])) {
+        this.handleArraySchema(key, schema, pointer, compiledSchema);
+        continue;
+      }
+
+      if (isObject(schema[key])) {
+        this.handleObjectSchema(key, schema, pointer, compiledSchema);
+        continue;
+      }
+    }
+
+    return compiledSchema;
+  }
+
+  private handleArraySchema(
+    key: string,
+    schema: any,
+    pointer: string,
+    compiledSchema: any
+  ) {
+    compiledSchema[key] = schema[key].map((subSchema, index) => {
+      if (typeof subSchema === "object" && subSchema !== null) {
+        if ("type" in subSchema) {
+          return this.compileSchema(subSchema, `${pointer}/${key}/${index}`);
+        }
+
+        for (let subKey in subSchema) {
+          if (this.keywords.has(subKey)) {
+            return this.compileSchema(subSchema, `${pointer}/${key}/${index}`);
+          }
+        }
+      }
+      return subSchema;
+    });
+  }
+
+  private handleObjectSchema(
+    key: string,
+    schema: any,
+    pointer: string,
+    compiledSchema: any
+  ) {
+    if ("type" in schema[key]) {
+      compiledSchema[key] = this.compileSchema(
+        schema[key],
+        `${pointer}/${key}`
+      );
+      return;
+    }
+
+    for (let subKey in schema[key]) {
+      compiledSchema[key] = compiledSchema[key] || {};
+
+      if (this.keywords.has(subKey)) {
+        compiledSchema[key][subKey] = this.compileSchema(
+          schema[key][subKey],
+          `${pointer}/${subKey}`
+        );
+        continue;
+      }
+
+      if (typeof schema[key][subKey] === "object") {
+        if ("type" in schema[key][subKey]) {
+          compiledSchema[key][subKey] = this.compileSchema(
+            schema[key][subKey],
+            `${pointer}/${key}/${subKey}`
+          );
+          continue;
+        }
+
+        for (let subSubKey in schema[key][subKey]) {
+          if (this.keywords.has(subSubKey)) {
+            compiledSchema[key][subKey] = this.compileSchema(
+              schema[key][subKey],
+              `${pointer}/${key}/${subKey}`
+            );
+            continue;
+          }
+        }
+      }
+    }
+  }
+
+  private validateTypes(schema: CompiledSchema, data, pointer): Result {
+    if (
+      typeof data === "undefined" ||
+      !Array.isArray(schema.validators) ||
+      schema.validators.length === 0
+    ) {
+      return {
+        valid: true,
+        errors: [],
+        data
+      };
+    }
+
+    let errors = [];
+    let finalData = data;
+
+    for (let schemaValidator of schema.validators) {
+      const schemaResult = schemaValidator(schema, data, pointer, this);
+
+      finalData = schemaResult.data;
+
+      if (schemaResult.valid) {
+        return schemaResult;
+      }
+
+      errors = schemaResult.errors;
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      data: finalData
+    };
+  }
+
+  private validateKeywords(schema: CompiledSchema, data, pointer): Result {
+    const errors = [];
+    let finalData = data;
+
+    if ("keywords" in schema) {
+      for (let keyword in schema.keywords) {
+        const keywordValidator: ValidatorFunction = schema.keywords[keyword];
+        const keywordResult = keywordValidator(
+          schema,
+          finalData,
+          pointer,
+          this
+        );
+        finalData = keywordResult.data;
+        if (!keywordResult.valid) {
+          errors.push(...keywordResult.errors);
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      data: finalData
+    };
+  }
+}

package/lib/keywords/array-keywords.ts

@@ -0,0 +1,204 @@
+import { CompiledSchema, ValidatorFunction } from "../index";
+import { ValidationError, isObject } from "../utils";
+
+export const ArrayKeywords: Record<string, ValidatorFunction> = {
+  items(schema, data, pointer, schemaShieldInstance) {
+    if (!Array.isArray(data)) {
+      return { valid: true, errors: [], data };
+    }
+
+    const errors = [];
+    let finalData = [...data];
+    if (Array.isArray(schema.items)) {
+      for (let i = 0; i < schema.items.length; i++) {
+        if (typeof schema.items[i] === "boolean") {
+          if (schema.items[i] === false && typeof data[i] !== "undefined") {
+            errors.push(
+              new ValidationError("Array item is not allowed", {
+                pointer: `${pointer}/${i}`,
+                value: data[i],
+                code: "ARRAY_ITEM_NOT_ALLOWED"
+              })
+            );
+          }
+          continue;
+        }
+
+        const { validator } = schema.items[i] as CompiledSchema;
+        if (!validator) {
+          continue;
+        }
+        const validatorResult = validator(
+          schema.items[i],
+          finalData[i],
+          `${pointer}/${i}`,
+          schemaShieldInstance
+        );
+
+        finalData[i] = validatorResult.data;
+
+        if (!validatorResult.valid) {
+          errors.push(...validatorResult.errors);
+        }
+      }
+    } else if (typeof schema.items === "boolean") {
+      if (schema.items === false && data.length > 0) {
+        errors.push(
+          new ValidationError("Array is not allowed", {
+            pointer,
+            value: data,
+            code: "ARRAY_NOT_ALLOWED"
+          })
+        );
+      }
+    } else {
+      const { validator } = schema.items as CompiledSchema;
+      if (!validator) {
+        return { valid: true, errors: [], data };
+      }
+
+      for (let i = 0; i < finalData.length; i++) {
+        const validatorErrors = validator(
+          schema.items,
+          finalData[i],
+          `${pointer}/${i}`,
+          schemaShieldInstance
+        );
+
+        finalData[i] = validatorErrors.data;
+
+        if (!validatorErrors.valid) {
+          errors.push(...validatorErrors.errors);
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  },
+
+  minItems(schema, data, pointer) {
+    if (!Array.isArray(data) || data.length >= schema.minItems) {
+      return { valid: true, errors: [], data };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("Array is too short", {
+          pointer,
+          value: data,
+          code: "ARRAY_TOO_SHORT"
+        })
+      ],
+      data
+    };
+  },
+
+  maxItems(schema, data, pointer) {
+    if (!Array.isArray(data) || data.length <= schema.maxItems) {
+      return { valid: true, errors: [], data };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("Array is too long", {
+          pointer,
+          value: data,
+          code: "ARRAY_TOO_LONG"
+        })
+      ],
+      data
+    };
+  },
+
+  additionalItems(schema, data, pointer, schemaShieldInstance) {
+    if (!Array.isArray(data) || !schema.items || !Array.isArray(schema.items)) {
+      return { valid: true, errors: [], data };
+    }
+
+    if (schema.additionalItems === false) {
+      if (data.length > schema.items.length) {
+        return {
+          valid: false,
+          errors: [
+            new ValidationError("Array has too many items", {
+              pointer,
+              value: data,
+              code: "ARRAY_TOO_MANY_ITEMS"
+            })
+          ],
+          data
+        };
+      }
+
+      return { valid: true, errors: [], data };
+    }
+
+    const errors = [];
+    let finalData = [...data];
+    if (typeof schema.additionalItems === "object") {
+      for (let i = schema.items.length; i < finalData.length; i++) {
+        const { validator } = schema.additionalItems as CompiledSchema;
+        const validatorResult = validator(
+          schema.additionalItems,
+          finalData[i],
+          `${pointer}/${i}`,
+          schemaShieldInstance
+        );
+        if (!validatorResult.valid) {
+          errors.push(...validatorResult.errors);
+        }
+        finalData[i] = validatorResult.data;
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  },
+
+  uniqueItems(schema, data, pointer) {
+    if (!Array.isArray(data) || !schema.uniqueItems) {
+      return { valid: true, errors: [], data };
+    }
+
+    const unique = new Set();
+
+    for (const item of data) {
+      let itemStr = item;
+
+      // Change string to "string" to avoid false positives
+      if (typeof item === "string") {
+        itemStr = `"${item}"`;
+
+        // Sort object keys to avoid false positives
+      } else if (isObject(item)) {
+        const keys = Object.keys(item).sort();
+        const sorted = {};
+        for (let i = 0; i < keys.length; i++) {
+          sorted[keys[i]] = item[keys[i]];
+        }
+        itemStr = JSON.stringify(sorted);
+      } else if (Array.isArray(item)) {
+        itemStr = JSON.stringify(item);
+      }
+
+      if (unique.has(itemStr)) {
+        return {
+          valid: false,
+          errors: [
+            new ValidationError("Array items are not unique", {
+              pointer,
+              value: data,
+              code: "ARRAY_ITEMS_NOT_UNIQUE"
+            })
+          ],
+          data
+        };
+      } else {
+        unique.add(itemStr);
+      }
+    }
+
+    return { valid: true, errors: [], data };
+  }
+};