@takeshape/json-schema 11.52.0 → 11.55.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,16 +1 @@
-"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];
-    }
-  });
-});
+export * from "./schema-validator.js";

package/dist/schema-validator.d.ts

@@ -1,5 +1,5 @@
 import type { ErrorObject, Options, SchemaObject } from 'ajv';
-import Ajv from 'ajv';
+import { Ajv } from 'ajv';
 export type Data = any;
 export type ValidateParams = {
     ignoreMissing: boolean;
@@ -29,4 +29,3 @@ export declare function createAjv(options?: Options): Ajv;
  */
 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/dist/schema-validator.js

@@ -1,226 +1,200 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Ajv", {
-  enumerable: true,
-  get: function () {
-    return _ajv.default;
-  }
-});
-exports.createAjv = createAjv;
-exports.createSchemaValidator = createSchemaValidator;
-exports.fixSchema = fixSchema;
-exports.followSchemaPath = followSchemaPath;
-exports.isInvalidPropertyRequired = isInvalidPropertyRequired;
-exports.parseDataPath = parseDataPath;
-exports.refToPath = refToPath;
-exports.validate = validate;
-var _util = require("@takeshape/util");
-var _ajv = _interopRequireDefault(require("ajv"));
-var _ajvFormats = _interopRequireDefault(require("ajv-formats"));
-var _get = _interopRequireDefault(require("lodash/get"));
-var _isString = _interopRequireDefault(require("lodash/isString"));
-var _unset = _interopRequireDefault(require("lodash/unset"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function parseDataPath(instancePath) {
-  return instancePath.substr(1).split('/');
+import { visit } from '@takeshape/util';
+import { Ajv } from 'ajv';
+import addFormats from 'ajv-formats';
+import get from 'lodash/get.js';
+import isString from 'lodash/isString.js';
+import unset from 'lodash/unset.js';
+export function parseDataPath(instancePath) {
+    return instancePath.substr(1).split('/');
 }
 function getData(error, data) {
-  return (0, _get.default)(data, parseDataPath(error.instancePath));
+    return get(data, parseDataPath(error.instancePath));
 }
 function ignoreMissing(error) {
-  // ignore top level missing errors
-  return !(error.instancePath === '' && error.keyword === 'required');
+    // 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));
+    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));
-}
-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);
+    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));
+    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];
+    const parts = parseDataPath(path);
+    return parts[parts.length - 1];
 }
-function refToPath(ref) {
-  return ref.substring(2).split('/');
+export function refToPath(ref) {
+    return ref.substring(2).split('/');
 }
 function followRef(topLevelSchema, schema) {
-  if (schema.$ref) {
-    const referencedSchema = (0, _get.default)(topLevelSchema, refToPath(schema.$ref));
-    if (!referencedSchema) {
-      throw new Error(`Could not resolve ${schema.$ref}`);
+    if (schema.$ref) {
+        const referencedSchema = get(topLevelSchema, refToPath(schema.$ref));
+        if (!referencedSchema) {
+            throw new Error(`Could not resolve ${schema.$ref}`);
+        }
+        return referencedSchema;
     }
-    return referencedSchema;
-  }
-  return schema;
+    return schema;
 }
-
 /**
  * Given a schema object traverse it using a "instancePath" and return the schema at that path
  */
-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;
+export function followSchemaPath(topLevelSchema, instancePath) {
+    const followPath = (schemaObject, path) => {
+        const schema = followRef(topLevelSchema, schemaObject);
+        if (path.length === 0) {
+            return schema;
         }
-      }
-    }
-    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);
+        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';
+    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 {
-        ...(0, _get.default)(rootSchema, path),
-        definitions
-      };
+    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 = [];
     }
-  }
-  return ajv.getSchema(id)?.schema;
-}
-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;
-      }
+    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
-  };
-}
-function createAjv(options) {
-  const ajv = new _ajv.default({
-    discriminator: true,
-    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;
-}
-
+    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.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 {
-    new RegExp(str, 'u');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
+    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.
  */
-function fixSchema(schema) {
-  (0, _util.visit)(schema, ['pattern', 'oneOf'], (value, path) => {
-    const key = path.slice(-1)[0];
-    const parent = (0, _get.default)(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' && (!(0, _isString.default)(value) || !isValidRegex(value))) {
-        (0, _unset.default)(schema, path);
-      }
+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));
     }
-  });
-  return schema;
-}
-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);
+    const defaultRef = schemas[0].$id;
+    if (!defaultRef) {
+        throw Error('Failed to create schema validator: schema is missing $id');
     }
-  }
-  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);
-  };
-}
+    return (data, options) => {
+        return validate(ajv, defaultRef, data, options);
+    };
+}

package/dist/utils/__tests__/references.test.d.ts

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

package/dist/utils/__tests__/references.test.js

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest';
+import { getReferenceMap } from "../references.js";
+describe('getReferenceMap', () => {
+    it('should return an empty map when no definitions are provided', () => {
+        const definitions = {};
+        const result = getReferenceMap(definitions);
+        expect(result.size).toBe(0);
+    });
+    it('should collect references from property schemas', () => {
+        const definitions = {
+            A: {
+                type: 'object',
+                properties: {
+                    b: { $ref: '#/definitions/B' }
+                }
+            },
+            B: {
+                type: 'object',
+                properties: {}
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('A')).toEqual(new Set(['B']));
+    });
+    it('should collect references from allOf schemas', () => {
+        const definitions = {
+            A: {
+                allOf: [{ $ref: '#/definitions/B' }]
+            },
+            B: {
+                type: 'object',
+                properties: {}
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('A')).toEqual(new Set(['B']));
+    });
+    it('should collect references from anyOf schemas', () => {
+        const definitions = {
+            A: {
+                anyOf: [{ $ref: '#/definitions/B' }]
+            },
+            B: {
+                type: 'object',
+                properties: {}
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('A')).toEqual(new Set(['B']));
+    });
+    it('should collect references from oneOf schemas', () => {
+        const definitions = {
+            A: {
+                oneOf: [{ $ref: '#/definitions/B' }]
+            },
+            B: {
+                type: 'object',
+                properties: {}
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('A')).toEqual(new Set(['B']));
+    });
+    it('should collect references from items schemas', () => {
+        const definitions = {
+            A: {
+                type: 'array',
+                items: { $ref: '#/definitions/B' }
+            },
+            B: {
+                type: 'object',
+                properties: {}
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('A')).toEqual(new Set(['B']));
+    });
+    it('should handle circular references', () => {
+        const definitions = {
+            A: {
+                $ref: '#/definitions/B'
+            },
+            B: {
+                $ref: '#/definitions/A'
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('A')).toEqual(new Set(['B']));
+        expect(result.get('B')).toEqual(new Set(['A']));
+    });
+    it('should handle deeply nested references', () => {
+        const definitions = {
+            Z: {
+                type: 'string'
+            },
+            A: {
+                type: 'object',
+                properties: {
+                    Z: {
+                        $ref: '#/definitions/Z'
+                    }
+                }
+            },
+            B: {
+                type: 'object',
+                properties: {
+                    C: {
+                        type: 'object',
+                        properties: {
+                            D: {
+                                $ref: '#/definitions/A'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const result = getReferenceMap(definitions);
+        expect(result.get('B')).toEqual(new Set(['A', 'Z']));
+    });
+});

package/dist/utils/__tests__/type-utils.test.d.ts

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