@takeshape/json-schema 7.194.0

package/README.md

@@ -0,0 +1,5 @@
+# JSON Schema
+
+## Summary
+
+A set of utilities for working with [JSON Schema](https://json-schema.org/) and [AJV](https://github.com/ajv-validator/ajv)

package/es/index.js

@@ -0,0 +1 @@
+export * from './schema-validator';

package/es/schema-validator.js

@@ -0,0 +1,223 @@
+import Ajv, { ErrorObject } from 'ajv';
+import addFormats from 'ajv-formats';
+import get from 'lodash/get';
+export function parseDataPath(dataPath) {
+  return dataPath.substr(1).split('/');
+}
+
+function getData(error, data) {
+  return get(data, parseDataPath(error.dataPath));
+}
+
+function ignoreMissing(error) {
+  // ignore top level missing errors
+  return !(error.dataPath === '' && error.keyword === 'required');
+}
+
+function ignoreNull(error, data, schema) {
+  return !((error.keyword === 'type' || error.keyword === 'oneOf') && getData(error, data) === null && !isInvalidPropertyRequired(schema, error));
+}
+
+function getErrorFilter(params, data, schema) {
+  return error => (!params.ignoreMissing || ignoreMissing(error)) && (!params.ignoreNulls || ignoreNull(error, data, schema));
+}
+
+export function isInvalidPropertyRequired(schema, error) {
+  const dataPath = parseDataPath(error.dataPath);
+  const parentDataPath = dataPath.slice(0, dataPath.length - 1);
+  const parentSchema = followSchemaPath(schema, parentDataPath);
+  const name = getName(error.dataPath);
+
+  if (!parentSchema) {
+    throw new Error('Unexpected error cannot find parent schema');
+  }
+
+  return isRequired(schema, parentSchema, name);
+}
+
+function isRequired(topLevelSchema, schema, name) {
+  const schemas = schema.allOf || schema.anyOf || schema.oneOf || [schema];
+  return schemas.some(childSchema => {
+    var _followRef, _followRef$required;
+
+    return (_followRef = followRef(topLevelSchema, childSchema)) === null || _followRef === void 0 ? void 0 : (_followRef$required = _followRef.required) === null || _followRef$required === void 0 ? void 0 : _followRef$required.find(prop => prop === name);
+  });
+}
+
+function getName(path) {
+  const parts = parseDataPath(path);
+  return parts[parts.length - 1];
+}
+
+export function refToPath(ref) {
+  return ref.substr(2).split('/');
+}
+
+function followRef(topLevelSchema, schema) {
+  return schema.$ref ? get(topLevelSchema, refToPath(schema.$ref)) : schema;
+}
+/**
+ * Given a schema object traverse it using a "dataPath" and return the schema at that path
+ */
+
+
+export function followSchemaPath(topLevelSchema, dataPath) {
+  const followPath = (schema, path) => {
+    var _schema, _schema$properties;
+
+    schema = followRef(topLevelSchema, schema);
+
+    if (path.length === 0) {
+      return schema;
+    }
+
+    const combinedSchemas = schema.allOf || schema.anyOf || schema.oneOf;
+
+    if (combinedSchemas) {
+      for (const childSchema of combinedSchemas) {
+        const result = followPath(childSchema, path);
+
+        if (result) {
+          return result;
+        }
+      }
+    }
+
+    const [first, ...rest] = path;
+
+    if (schema.items && /^\d+$/.exec(first)) {
+      return followPath(schema.items, rest);
+    }
+
+    const prop = (_schema = schema) === null || _schema === void 0 ? void 0 : (_schema$properties = _schema.properties) === null || _schema$properties === void 0 ? void 0 : _schema$properties[first];
+
+    if (prop) {
+      return rest.length ? followPath(prop, rest) : prop;
+    }
+  };
+
+  return followPath(topLevelSchema, dataPath);
+}
+
+function isSchemaObject(schema) {
+  return typeof schema === 'object';
+}
+
+export function validate(ajv, id, data, options) {
+  const params = {
+    ignoreMissing: false,
+    ignoreNulls: true,
+    errorsText: false,
+    ...options
+  };
+  let valid = ajv.validate(id, data);
+  let errors;
+
+  if (valid) {
+    errors = [];
+  } else {
+    errors = ajv.errors;
+
+    if (params.ignoreNulls || params.ignoreMissing) {
+      var _ajv$getSchema;
+
+      const schema = (_ajv$getSchema = ajv.getSchema(id)) === null || _ajv$getSchema === void 0 ? void 0 : _ajv$getSchema.schema;
+
+      if (isSchemaObject(schema)) {
+        errors = errors.filter(getErrorFilter(params, data, schema));
+        valid = errors.length === 0;
+      }
+    }
+  }
+
+  const errorsText = params.errorsText && !valid ? ajv.errorsText(errors) : '';
+  return {
+    valid,
+    errors,
+    errorsText
+  };
+}
+export { Ajv, ErrorObject };
+export function createAjv(options) {
+  const ajv = new Ajv({
+    allErrors: true,
+    unevaluated: true,
+    strict: false,
+    ...options
+  });
+  addFormats(ajv);
+  /**
+   * Formats ingested by Stripe OpenAPI and possibly other — trigger warnings
+   * in the client when Stripe types are loaded.
+   */
+
+  ajv.addFormat('unix-time', /^[0-9]{10}$/);
+  ajv.addFormat('decimal', /^[0-9]+\.[0-9]{1,12}$/);
+  return ajv;
+}
+/**
+ * Determine whether a string is a valid regular expression
+ */
+
+function isValidRegex(str) {
+  try {
+    // eslint-disable-next-line no-new,security-node/non-literal-reg-expr
+    new RegExp(str, 'u');
+    return true;
+  } catch {
+    return false;
+  }
+}
+/**
+ * Fix schema by removing any broken regexes that will cause ajv to throw a compile error.
+ * It is better to remove the invalid regex rather than forgo validation altogether
+ * This should be fixed in ajv see the comment here
+ * https://github.com/ajv-validator/ajv/blob/9f1c3eaa4b91ca17b72b122cdac9b108d1ac30cb/lib/vocabularies/validation/pattern.ts#L21
+ */
+
+
+export function fixSchema(schema) {
+  const normalize = obj => {
+    if (Array.isArray(obj)) {
+      return obj.map(normalize);
+    }
+
+    if (obj && typeof obj === 'object') {
+      const result = {};
+
+      for (const key of Object.keys(obj)) {
+        if (key !== 'pattern' || obj.type !== 'string' || isValidRegex(obj[key])) {
+          result[key] = normalize(obj[key]);
+        }
+      }
+
+      return result;
+    }
+
+    return obj;
+  };
+
+  return normalize(schema);
+}
+export function createSchemaValidator(schema, metaSchemas = [], options = {}) {
+  const schemas = Array.isArray(schema) ? schema : [schema];
+  const ajv = createAjv({
+    removeAdditional: true,
+    ...options
+  });
+
+  if (metaSchemas) {
+    metaSchemas.forEach(metaSchema => ajv.addMetaSchema(metaSchema));
+  }
+
+  schemas.forEach(schema => ajv.addSchema(fixSchema(schema)));
+  const defaultRef = schemas[0].$id;
+
+  if (!defaultRef) {
+    throw Error('Failed to create schema validator: schema is missing $id');
+  }
+
+  return (data, options) => {
+    return validate(ajv, defaultRef, data, options);
+  };
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema-validator';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _schemaValidator = require("./schema-validator");
+
+Object.keys(_schemaValidator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _schemaValidator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _schemaValidator[key];
+    }
+  });
+});

package/lib/schema-validator.d.ts

@@ -0,0 +1,33 @@
+import Ajv, { ErrorObject, Options, SchemaObject } from 'ajv';
+export declare type Data = any;
+export interface ValidateParams {
+    ignoreMissing: boolean;
+    ignoreNulls: boolean;
+    errorsText: boolean;
+}
+export interface ValidateResult {
+    valid: boolean;
+    errorsText: string;
+    errors: ErrorObject[];
+}
+export declare type Validator = (data: Data, options?: Partial<ValidateParams>) => ValidateResult;
+export declare function parseDataPath(dataPath: string): string[];
+export declare function isInvalidPropertyRequired(schema: SchemaObject, error: ErrorObject): boolean;
+export declare function refToPath(ref: string): string[];
+/**
+ * Given a schema object traverse it using a "dataPath" and return the schema at that path
+ */
+export declare function followSchemaPath(topLevelSchema: SchemaObject, dataPath: string[]): SchemaObject | undefined;
+export declare type MinimalAjv = Pick<Ajv, 'validate' | 'errors' | 'getSchema' | 'errorsText'>;
+export declare function validate(ajv: MinimalAjv, id: string, data: Data, options?: Partial<ValidateParams>): ValidateResult;
+export { Ajv, ErrorObject };
+export declare function createAjv(options?: Options): Ajv;
+/**
+ * Fix schema by removing any broken regexes that will cause ajv to throw a compile error.
+ * It is better to remove the invalid regex rather than forgo validation altogether
+ * This should be fixed in ajv see the comment here
+ * https://github.com/ajv-validator/ajv/blob/9f1c3eaa4b91ca17b72b122cdac9b108d1ac30cb/lib/vocabularies/validation/pattern.ts#L21
+ */
+export declare function fixSchema(schema: SchemaObject): SchemaObject;
+export declare function createSchemaValidator(schema: SchemaObject | SchemaObject[], metaSchemas?: SchemaObject[], options?: Options): Validator;
+//# sourceMappingURL=schema-validator.d.ts.map

package/lib/schema-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validator.d.ts","sourceRoot":"","sources":["../../src/schema-validator.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,EAAE,EAAC,WAAW,EAAE,OAAO,EAAE,YAAY,EAAC,MAAM,KAAK,CAAC;AAI5D,oBAAY,IAAI,GAAG,GAAG,CAAC;AAEvB,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,oBAAY,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,KAAK,cAAc,CAAC;AAE1F,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAExD;AAwBD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAW3F;AAcD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAE/C;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,YAAY,GAAG,SAAS,CA6B3G;AAED,oBAAY,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC,CAAC;AAMvF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,CA2BnH;AAED,OAAO,EAAC,GAAG,EAAE,WAAW,EAAC,CAAC;AAC1B,wBAAgB,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,GAAG,CAkBhD;AAeD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAiB5D;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,GAAG,YAAY,EAAE,EACrC,WAAW,GAAE,YAAY,EAAO,EAChC,OAAO,GAAE,OAAY,GACpB,SAAS,CAqBX"}

package/lib/schema-validator.js

@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseDataPath = parseDataPath;
+exports.isInvalidPropertyRequired = isInvalidPropertyRequired;
+exports.refToPath = refToPath;
+exports.followSchemaPath = followSchemaPath;
+exports.validate = validate;
+exports.createAjv = createAjv;
+exports.fixSchema = fixSchema;
+exports.createSchemaValidator = createSchemaValidator;
+Object.defineProperty(exports, "Ajv", {
+  enumerable: true,
+  get: function () {
+    return _ajv.default;
+  }
+});
+Object.defineProperty(exports, "ErrorObject", {
+  enumerable: true,
+  get: function () {
+    return _ajv.ErrorObject;
+  }
+});
+
+var _ajv = _interopRequireWildcard(require("ajv"));
+
+var _ajvFormats = _interopRequireDefault(require("ajv-formats"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function parseDataPath(dataPath) {
+  return dataPath.substr(1).split('/');
+}
+
+function getData(error, data) {
+  return (0, _get.default)(data, parseDataPath(error.dataPath));
+}
+
+function ignoreMissing(error) {
+  // ignore top level missing errors
+  return !(error.dataPath === '' && error.keyword === 'required');
+}
+
+function ignoreNull(error, data, schema) {
+  return !((error.keyword === 'type' || error.keyword === 'oneOf') && getData(error, data) === null && !isInvalidPropertyRequired(schema, error));
+}
+
+function getErrorFilter(params, data, schema) {
+  return error => (!params.ignoreMissing || ignoreMissing(error)) && (!params.ignoreNulls || ignoreNull(error, data, schema));
+}
+
+function isInvalidPropertyRequired(schema, error) {
+  const dataPath = parseDataPath(error.dataPath);
+  const parentDataPath = dataPath.slice(0, dataPath.length - 1);
+  const parentSchema = followSchemaPath(schema, parentDataPath);
+  const name = getName(error.dataPath);
+
+  if (!parentSchema) {
+    throw new Error('Unexpected error cannot find parent schema');
+  }
+
+  return isRequired(schema, parentSchema, name);
+}
+
+function isRequired(topLevelSchema, schema, name) {
+  const schemas = schema.allOf || schema.anyOf || schema.oneOf || [schema];
+  return schemas.some(childSchema => {
+    var _followRef, _followRef$required;
+
+    return (_followRef = followRef(topLevelSchema, childSchema)) === null || _followRef === void 0 ? void 0 : (_followRef$required = _followRef.required) === null || _followRef$required === void 0 ? void 0 : _followRef$required.find(prop => prop === name);
+  });
+}
+
+function getName(path) {
+  const parts = parseDataPath(path);
+  return parts[parts.length - 1];
+}
+
+function refToPath(ref) {
+  return ref.substr(2).split('/');
+}
+
+function followRef(topLevelSchema, schema) {
+  return schema.$ref ? (0, _get.default)(topLevelSchema, refToPath(schema.$ref)) : schema;
+}
+/**
+ * Given a schema object traverse it using a "dataPath" and return the schema at that path
+ */
+
+
+function followSchemaPath(topLevelSchema, dataPath) {
+  const followPath = (schema, path) => {
+    var _schema, _schema$properties;
+
+    schema = followRef(topLevelSchema, schema);
+
+    if (path.length === 0) {
+      return schema;
+    }
+
+    const combinedSchemas = schema.allOf || schema.anyOf || schema.oneOf;
+
+    if (combinedSchemas) {
+      for (const childSchema of combinedSchemas) {
+        const result = followPath(childSchema, path);
+
+        if (result) {
+          return result;
+        }
+      }
+    }
+
+    const [first, ...rest] = path;
+
+    if (schema.items && /^\d+$/.exec(first)) {
+      return followPath(schema.items, rest);
+    }
+
+    const prop = (_schema = schema) === null || _schema === void 0 ? void 0 : (_schema$properties = _schema.properties) === null || _schema$properties === void 0 ? void 0 : _schema$properties[first];
+
+    if (prop) {
+      return rest.length ? followPath(prop, rest) : prop;
+    }
+  };
+
+  return followPath(topLevelSchema, dataPath);
+}
+
+function isSchemaObject(schema) {
+  return typeof schema === 'object';
+}
+
+function validate(ajv, id, data, options) {
+  const params = {
+    ignoreMissing: false,
+    ignoreNulls: true,
+    errorsText: false,
+    ...options
+  };
+  let valid = ajv.validate(id, data);
+  let errors;
+
+  if (valid) {
+    errors = [];
+  } else {
+    errors = ajv.errors;
+
+    if (params.ignoreNulls || params.ignoreMissing) {
+      var _ajv$getSchema;
+
+      const schema = (_ajv$getSchema = ajv.getSchema(id)) === null || _ajv$getSchema === void 0 ? void 0 : _ajv$getSchema.schema;
+
+      if (isSchemaObject(schema)) {
+        errors = errors.filter(getErrorFilter(params, data, schema));
+        valid = errors.length === 0;
+      }
+    }
+  }
+
+  const errorsText = params.errorsText && !valid ? ajv.errorsText(errors) : '';
+  return {
+    valid,
+    errors,
+    errorsText
+  };
+}
+
+function createAjv(options) {
+  const ajv = new _ajv.default({
+    allErrors: true,
+    unevaluated: true,
+    strict: false,
+    ...options
+  });
+  (0, _ajvFormats.default)(ajv);
+  /**
+   * Formats ingested by Stripe OpenAPI and possibly other — trigger warnings
+   * in the client when Stripe types are loaded.
+   */
+
+  ajv.addFormat('unix-time', /^[0-9]{10}$/);
+  ajv.addFormat('decimal', /^[0-9]+\.[0-9]{1,12}$/);
+  return ajv;
+}
+/**
+ * Determine whether a string is a valid regular expression
+ */
+
+
+function isValidRegex(str) {
+  try {
+    // eslint-disable-next-line no-new,security-node/non-literal-reg-expr
+    new RegExp(str, 'u');
+    return true;
+  } catch {
+    return false;
+  }
+}
+/**
+ * Fix schema by removing any broken regexes that will cause ajv to throw a compile error.
+ * It is better to remove the invalid regex rather than forgo validation altogether
+ * This should be fixed in ajv see the comment here
+ * https://github.com/ajv-validator/ajv/blob/9f1c3eaa4b91ca17b72b122cdac9b108d1ac30cb/lib/vocabularies/validation/pattern.ts#L21
+ */
+
+
+function fixSchema(schema) {
+  const normalize = obj => {
+    if (Array.isArray(obj)) {
+      return obj.map(normalize);
+    }
+
+    if (obj && typeof obj === 'object') {
+      const result = {};
+
+      for (const key of Object.keys(obj)) {
+        if (key !== 'pattern' || obj.type !== 'string' || isValidRegex(obj[key])) {
+          result[key] = normalize(obj[key]);
+        }
+      }
+
+      return result;
+    }
+
+    return obj;
+  };
+
+  return normalize(schema);
+}
+
+function createSchemaValidator(schema, metaSchemas = [], options = {}) {
+  const schemas = Array.isArray(schema) ? schema : [schema];
+  const ajv = createAjv({
+    removeAdditional: true,
+    ...options
+  });
+
+  if (metaSchemas) {
+    metaSchemas.forEach(metaSchema => ajv.addMetaSchema(metaSchema));
+  }
+
+  schemas.forEach(schema => ajv.addSchema(fixSchema(schema)));
+  const defaultRef = schemas[0].$id;
+
+  if (!defaultRef) {
+    throw Error('Failed to create schema validator: schema is missing $id');
+  }
+
+  return (data, options) => {
+    return validate(ajv, defaultRef, data, options);
+  };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@takeshape/json-schema",
+  "version": "7.194.0",
+  "description": "JSON Schema validator",
+  "homepage": "https://www.takeshape.io",
+  "repository": {
+    "type": "git",
+    "url": "github.com:takeshape/takeshape.git"
+  },
+  "author": "asprouse",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=12"
+  },
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "es"
+  ],
+  "dependencies": {
+    "ajv": "^7.0.4",
+    "ajv-formats": "^1.5.1",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.165"
+  },
+  "scripts": {
+    "lint": "eslint . --ext .js,.ts",
+    "lint:code:ci": "eslint . --ext .js,.ts --format junit -o \"${HOME}/test-results/${npm_package_name#*\\/}/eslint-results.xml\"",
+    "test": "jest",
+    "test-changed": "pnpm run test -- --changedSince=master",
+    "test:ci": "JEST_JUNIT_OUTPUT_DIR=\"${HOME}/test-results/${npm_package_name#*\\/}\" JEST_JUNIT_OUTPUT_NAME=jest-results.xml jest --ci --reporters=default --reporters=jest-junit",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf lib es build *.tsbuildinfo",
+    "build": "pnpm clean && pnpm build:types && pnpm build:js && pnpm build:es && pnpm build:copy",
+    "build:types": "tsc --emitDeclarationOnly --project tsconfig.build.json",
+    "build:js": "cross-env BABEL_MODULES=commonjs babel src --out-dir lib --extensions \".js,.ts\" --ignore '**/__tests__'",
+    "build:es": "cross-env BABEL_MODULES=es babel src --out-dir es --extensions \".js,.ts\" --ignore '**/__tests__'",
+    "build:copy": "cp -rf build/src/* lib/",
+    "will-it-blend": "pnpm typecheck && pnpm lint -- --quiet && pnpm test -- --silent --coverage false"
+  }
+}