@takeshape/json-schema 11.52.0 → 11.55.0

package/es/schema-validator.js

@@ -1,207 +0,0 @@
-import { visit } from '@takeshape/util';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
-import get from 'lodash/get';
-import isString from 'lodash/isString';
-import unset from 'lodash/unset';
-export function parseDataPath(instancePath) {
-  return instancePath.substr(1).split('/');
-}
-function getData(error, data) {
-  return get(data, parseDataPath(error.instancePath));
-}
-function ignoreMissing(error) {
-  // ignore top level missing errors
-  return !(error.instancePath === '' && error.keyword === 'required');
-}
-function ignoreNull(error, data, topLevelSchema) {
-  return !((error.keyword === 'type' || error.keyword === 'oneOf') && getData(error, data) === null && !isInvalidPropertyRequired(topLevelSchema, error));
-}
-function getErrorFilter(params, data, schema) {
-  return error => (!params.ignoreMissing || ignoreMissing(error)) && (!params.ignoreNulls || ignoreNull(error, data, schema));
-}
-export function isInvalidPropertyRequired(topLevelSchema, error) {
-  const instancePath = parseDataPath(error.instancePath);
-  const parentDataPath = instancePath.slice(0, instancePath.length - 1);
-  const parentSchema = followSchemaPath(topLevelSchema, parentDataPath);
-  const name = getName(error.instancePath);
-  if (!parentSchema) {
-    throw new Error('Unexpected error cannot find parent schema');
-  }
-  return isRequired(topLevelSchema, parentSchema, name);
-}
-function isRequired(topLevelSchema, schema, name) {
-  const schemas = schema.allOf || schema.anyOf || schema.oneOf || [schema];
-  return schemas.some(childSchema => followRef(topLevelSchema, childSchema)?.required?.includes(name));
-}
-function getName(path) {
-  const parts = parseDataPath(path);
-  return parts[parts.length - 1];
-}
-export function refToPath(ref) {
-  return ref.substring(2).split('/');
-}
-function followRef(topLevelSchema, schema) {
-  if (schema.$ref) {
-    const referencedSchema = get(topLevelSchema, refToPath(schema.$ref));
-    if (!referencedSchema) {
-      throw new Error(`Could not resolve ${schema.$ref}`);
-    }
-    return referencedSchema;
-  }
-  return schema;
-}
-
-/**
- * Given a schema object traverse it using a "instancePath" and return the schema at that path
- */
-export function followSchemaPath(topLevelSchema, instancePath) {
-  const followPath = (schemaObject, path) => {
-    const schema = followRef(topLevelSchema, schemaObject);
-    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?.properties?.[first];
-    if (prop) {
-      return rest.length ? followPath(prop, rest) : prop;
-    }
-  };
-  return followPath(topLevelSchema, instancePath);
-}
-function isSchemaObject(schema) {
-  return typeof schema === 'object';
-}
-function getSchemaWithDefinitions(ajv, id) {
-  if (id.startsWith('#')) {
-    const rootSchema = ajv.getSchema('#')?.schema;
-    if (isSchemaObject(rootSchema)) {
-      const path = refToPath(id);
-      const {
-        definitions
-      } = rootSchema;
-      return {
-        ...get(rootSchema, path),
-        definitions
-      };
-    }
-  }
-  return ajv.getSchema(id)?.schema;
-}
-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) {
-      const schema = getSchemaWithDefinitions(ajv, id);
-      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 };
-export function createAjv(options) {
-  const ajv = new Ajv({
-    discriminator: true,
-    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 {
-    new RegExp(str, 'u');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Apply various fixes to the schema to work around AJV issues and bugs.
- * See inline comments for more.
- */
-export function fixSchema(schema) {
-  visit(schema, ['pattern', 'oneOf'], (value, path) => {
-    const key = path.slice(-1)[0];
-    const parent = get(schema, path.slice(0, -1));
-
-    /**
-     * 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
-     */
-    if (key === 'pattern') {
-      if (parent.type === 'string' && (!isString(value) || !isValidRegex(value))) {
-        unset(schema, path);
-      }
-    }
-  });
-  return schema;
-}
-export function createSchemaValidator(schema, metaSchemas = [], options = {}) {
-  const schemas = Array.isArray(schema) ? schema : [schema];
-  const ajv = createAjv({
-    removeAdditional: true,
-    ...options
-  });
-  if (metaSchemas) {
-    for (const metaSchema of metaSchemas) {
-      ajv.addMetaSchema(metaSchema);
-    }
-  }
-  for (const schema of schemas) {
-    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/es/utils/constants.js

@@ -1 +0,0 @@
-export const jsonSchema7Keys = ['$id', '$schema', '$ref', '$comment', 'title', 'description', 'default', 'readOnly', 'writeOnly', 'examples', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern', 'additionalItems', 'items', 'maxItems', 'minItems', 'uniqueItems', 'contains', 'maxProperties', 'minProperties', 'required', 'properties', 'patternProperties', 'additionalProperties', 'dependencies', 'propertyNames', 'const', 'enum', 'type', 'format', 'contentMediaType', 'contentEncoding', 'if', 'then', 'else', 'allOf', 'anyOf', 'oneOf', 'not', 'definitions', '$defs'];

package/es/utils/index.js

@@ -1,4 +0,0 @@
-export * from './type-utils';
-export * from './types';
-export * from './references';
-export * from './keys';

package/es/utils/keys.js

@@ -1,9 +0,0 @@
-import pick from 'lodash/pick';
-import { jsonSchema7Keys } from './constants';
-
-/**
- * Picks only valid JSON Schema 7 keys from the given schema.
- */
-export function pickJSONSchema7(schema) {
-  return pick(schema, jsonSchema7Keys);
-}

package/es/utils/references.js

@@ -1,66 +0,0 @@
-import { isAllOfSchema, isAnyOfSchema, isOneOfSchema, isPropertySchema, isRefSchema, isSchema } from './type-utils';
-const SCHEMA_DEFINITION_PREFIX = ['#/definitions/', '#/$defs/'];
-function collectRef(def, key, collect) {
-  if (isRefSchema(def)) {
-    collect(def.$ref, key);
-  } else if (isSchema(def)) {
-    collectRefs(def, key, collect);
-  }
-}
-function collectRefs(def, key, collect) {
-  if (isPropertySchema(def)) {
-    for (const d of Object.values(def.properties)) {
-      collectRef(d, key, collect);
-    }
-  } else if (isAllOfSchema(def)) {
-    for (const d of def.allOf) {
-      collectRef(d, key, collect);
-    }
-  } else if (isAnyOfSchema(def)) {
-    for (const d of def.anyOf) {
-      collectRef(d, key, collect);
-    }
-  } else if (isOneOfSchema(def)) {
-    for (const d of def.oneOf) {
-      collectRef(d, key, collect);
-    }
-  } else if (Array.isArray(def.items)) {
-    for (const d of def.items) {
-      collectRef(d, key, collect);
-    }
-  } else if (def.items) {
-    if (isSchema(def.items) && isRefSchema(def.items)) {
-      collect(def.items.$ref, key);
-    }
-  } else if (isRefSchema(def)) {
-    collect(def.$ref, key);
-  }
-}
-
-/**
- * Get all the definitions that are referenced by other definitions.
- */
-export function getReferenceMap(definitions) {
-  const references = new Map();
-  const addToReferenceMap = (ref, key) => {
-    const refKey = ref.replace(SCHEMA_DEFINITION_PREFIX[0], '').replace(SCHEMA_DEFINITION_PREFIX[1], '');
-    const refSet = references.get(key) ?? new Set();
-
-    // Circular reference
-    if (key === refKey) {
-      return;
-    }
-    refSet.add(refKey);
-    references.set(key, refSet);
-    const refDef = definitions[refKey];
-    if (refDef && isSchema(refDef)) {
-      collectRefs(refDef, key, addToReferenceMap);
-    }
-  };
-  for (const [key, def] of Object.entries(definitions)) {
-    if (isSchema(def)) {
-      collectRefs(def, key, addToReferenceMap);
-    }
-  }
-  return references;
-}

package/es/utils/type-utils.js

@@ -1,36 +0,0 @@
-export function isSchema(schema) {
-  return typeof schema !== 'boolean';
-}
-export function isOneOfSchema(schema) {
-  return isSchema(schema) && Array.isArray(schema.oneOf);
-}
-export function isAnyOfSchema(schema) {
-  return isSchema(schema) && Array.isArray(schema.anyOf);
-}
-export function isAllOfSchema(schema) {
-  return isSchema(schema) && Array.isArray(schema.allOf);
-}
-export function isUnionSchema(schema) {
-  return isOneOfSchema(schema) || isAnyOfSchema(schema) || isAllOfSchema(schema);
-}
-export function isObjectSchema(schema) {
-  return isSchema(schema) && schema.type === 'object';
-}
-export function isPropertySchema(schema) {
-  return isObjectSchema(schema) && typeof schema.properties === 'object';
-}
-export function isArraySchema(schema) {
-  return isSchema(schema) && schema.type === 'array';
-}
-export function isListSchema(schema) {
-  return isArraySchema(schema) && typeof schema.items === 'object' && !Array.isArray(schema.items);
-}
-export function isTupleSchema(schema) {
-  return isArraySchema(schema) && Array.isArray(schema.items);
-}
-export function isEnumSchema(schema) {
-  return Boolean(isSchema(schema) && schema.enum);
-}
-export function isRefSchema(schema) {
-  return Boolean(isSchema(schema) && schema.$ref);
-}

package/es/utils/types.js

@@ -1 +0,0 @@
-export {};