@takeshape/json-schema 11.144.1 → 11.154.1

package/dist/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.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 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.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;
-    }
-}
-/**
- * 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);
-    };
-}
-/**
- * Returns a compiled validator from a schema which can act as a type guard.
- */
-export function createTypedValidator(schema, options = {}) {
-    const ajv = createAjv(options);
-    return ajv.compile(schema);
-}

package/dist/utils/constants.d.ts

@@ -1,3 +0,0 @@
-import type { JSONSchema7 } from 'json-schema';
-export declare const jsonSchema7Keys: Array<keyof JSONSchema7>;
-export declare const jsonSchema7PrimitiveTypes: ["string", "number", "boolean", "integer", "null"];

package/dist/utils/constants.js

@@ -1,56 +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'
-];
-export const jsonSchema7PrimitiveTypes = [
-    'string',
-    'number',
-    'boolean',
-    'integer',
-    'null'
-];

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/keys.d.ts

@@ -1,5 +0,0 @@
-import type { JSONSchema7 } from 'json-schema';
-/**
- * Picks only valid JSON Schema 7 keys from the given schema.
- */
-export declare function pickJSONSchema7(schema: JSONSchema7): JSONSchema7;

package/dist/utils/keys.js

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

package/dist/utils/references.d.ts

@@ -1,145 +0,0 @@
-import type { JSONSchema7, JSONSchema7Definition } from 'json-schema';
-export declare function getDefinitionKey(ref: string): string;
-/**
- * Get all the definitions that are referenced by other definitions.
- */
-export declare function getReferenceMap(definitions: Record<string, JSONSchema7Definition>): Map<string, Set<string>>;
-/**
- * Prunes the schema definitions to only include those that are referenced either directly
- * or indirectly by the specified root reference.
- *
- * @param {JSONSchema7} schema - The JSON schema object containing the definitions to prune.
- * @param {string} ref - The reference identifier that serves as the root for pruning definitions.
- * @return {JSONSchema7} - A new JSON schema object with pruned definitions.
- */
-export declare function pruneSchemaDefinitions(schema: JSONSchema7, ref: string): {
-    definitions: Record<string, JSONSchema7Definition>;
-    $id?: string | undefined;
-    $ref?: string | undefined;
-    $schema?: import("json-schema").JSONSchema7Version | undefined;
-    $comment?: string | undefined;
-    $defs?: {
-        [key: string]: JSONSchema7Definition;
-    } | undefined;
-    type?: import("json-schema").JSONSchema7TypeName | import("json-schema").JSONSchema7TypeName[] | undefined;
-    enum?: import("json-schema").JSONSchema7Type[] | undefined;
-    const?: import("json-schema").JSONSchema7Type | undefined;
-    multipleOf?: number | undefined;
-    maximum?: number | undefined;
-    exclusiveMaximum?: number | undefined;
-    minimum?: number | undefined;
-    exclusiveMinimum?: number | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-    pattern?: string | undefined;
-    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
-    additionalItems?: JSONSchema7Definition | undefined;
-    maxItems?: number | undefined;
-    minItems?: number | undefined;
-    uniqueItems?: boolean | undefined;
-    contains?: JSONSchema7Definition | undefined;
-    maxProperties?: number | undefined;
-    minProperties?: number | undefined;
-    required?: string[] | undefined;
-    properties?: {
-        [key: string]: JSONSchema7Definition;
-    } | undefined;
-    patternProperties?: {
-        [key: string]: JSONSchema7Definition;
-    } | undefined;
-    additionalProperties?: JSONSchema7Definition | undefined;
-    dependencies?: {
-        [key: string]: JSONSchema7Definition | string[];
-    } | undefined;
-    propertyNames?: JSONSchema7Definition | undefined;
-    if?: JSONSchema7Definition | undefined;
-    then?: JSONSchema7Definition | undefined;
-    else?: JSONSchema7Definition | undefined;
-    allOf?: JSONSchema7Definition[] | undefined;
-    anyOf?: JSONSchema7Definition[] | undefined;
-    oneOf?: JSONSchema7Definition[] | undefined;
-    not?: JSONSchema7Definition | undefined;
-    format?: string | undefined;
-    contentMediaType?: string | undefined;
-    contentEncoding?: string | undefined;
-    title?: string | undefined;
-    description?: string | undefined;
-    default?: import("json-schema").JSONSchema7Type | undefined;
-    readOnly?: boolean | undefined;
-    writeOnly?: boolean | undefined;
-    examples?: import("json-schema").JSONSchema7Type | undefined;
-    discriminator?: {
-        propertyName: string;
-    };
-};
-/**
- * Promotes a specific object schema definition within a JSON Schema, potentially simplifying the schema
- * by focusing on the desired object and pruning unused definitions.
- *
- * Note this does not support promoting schemas that are self-referential
- *
- * @param {JSONSchema7} schema - The full JSON Schema to process.
- * @param {string} ref - The reference string identifying the target object schema within the definitions.
- * @return {ObjectSchemaWithProperties} The promoted object schema along with pruned definitions.
- * @throws {Error} If the specified reference does not correspond to a valid object definition within the schema.
- */
-export declare function promoteObjectSchema(schema: JSONSchema7, ref: string): {
-    definitions: {
-        [x: string]: JSONSchema7Definition;
-    };
-    minimum?: number | undefined | undefined;
-    maximum?: number | undefined | undefined;
-    exclusiveMinimum?: number | undefined | undefined;
-    exclusiveMaximum?: number | undefined | undefined;
-    multipleOf?: number | undefined | undefined;
-    format?: string | undefined | undefined;
-    allOf?: JSONSchema7Definition[] | undefined | undefined;
-    anyOf?: JSONSchema7Definition[] | undefined | undefined;
-    oneOf?: JSONSchema7Definition[] | undefined | undefined;
-    if?: JSONSchema7Definition | undefined;
-    then?: JSONSchema7Definition | undefined;
-    else?: JSONSchema7Definition | undefined;
-    not?: JSONSchema7Definition | undefined;
-    $id?: string | undefined | undefined;
-    $ref?: string | undefined | undefined;
-    $defs?: {
-        [key: string]: JSONSchema7Definition;
-    } | undefined | undefined;
-    $schema?: string | undefined;
-    $comment?: string | undefined | undefined;
-    type: "object";
-    enum?: import("json-schema").JSONSchema7Type[] | undefined | undefined;
-    const?: import("json-schema").JSONSchema7Type | undefined;
-    maxLength?: number | undefined | undefined;
-    minLength?: number | undefined | undefined;
-    pattern?: string | undefined | undefined;
-    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
-    additionalItems?: JSONSchema7Definition | undefined;
-    maxItems?: number | undefined | undefined;
-    minItems?: number | undefined | undefined;
-    uniqueItems?: boolean | undefined | undefined;
-    contains?: JSONSchema7Definition | undefined;
-    maxProperties?: number | undefined | undefined;
-    minProperties?: number | undefined | undefined;
-    required?: string[] | undefined | undefined;
-    patternProperties?: {
-        [key: string]: JSONSchema7Definition;
-    } | undefined | undefined;
-    additionalProperties?: JSONSchema7Definition | undefined;
-    dependencies?: {
-        [key: string]: JSONSchema7Definition | string[];
-    } | undefined | undefined;
-    propertyNames?: JSONSchema7Definition | undefined;
-    contentMediaType?: string | undefined | undefined;
-    contentEncoding?: string | undefined | undefined;
-    title?: string | undefined | undefined;
-    description?: string | undefined | undefined;
-    default?: import("json-schema").JSONSchema7Type | undefined;
-    readOnly?: boolean | undefined | undefined;
-    writeOnly?: boolean | undefined | undefined;
-    examples?: import("json-schema").JSONSchema7Type | undefined;
-    discriminator?: {
-        propertyName: string;
-    } | undefined;
-    properties: Exclude<JSONSchema7["properties"], undefined>;
-};

package/dist/utils/references.js

@@ -1,113 +0,0 @@
-import { visit } from '@takeshape/util';
-import { isObjectSchemaWithProperties, isSchema } from "./type-utils.js";
-function collectRefs(def, key, collect) {
-    if (!isSchema(def)) {
-        return;
-    }
-    visit(def, ['$ref'], ($ref) => {
-        if ($ref && typeof $ref === 'string') {
-            collect($ref, key);
-        }
-    });
-}
-export function getDefinitionKey(ref) {
-    const [, prefix, name] = ref.split('/');
-    if (!name || (prefix !== 'definitions' && prefix !== '$defs')) {
-        throw new Error(`Invalid reference: ${ref}`);
-    }
-    return name;
-}
-/**
- * Get all the definitions that are referenced by other definitions.
- */
-export function getReferenceMap(definitions) {
-    const references = new Map();
-    const visited = new Set();
-    const addToReferenceMap = (ref, key) => {
-        const refKey = getDefinitionKey(ref);
-        // Circular reference
-        if (key === refKey) {
-            return;
-        }
-        const visitKey = `${key}->${refKey}`;
-        if (visited.has(visitKey))
-            return;
-        visited.add(visitKey);
-        const refSet = references.get(key) ?? new Set();
-        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;
-}
-/**
- * Prunes the schema definitions to only include those that are referenced either directly
- * or indirectly by the specified root reference.
- *
- * @param {JSONSchema7} schema - The JSON schema object containing the definitions to prune.
- * @param {string} ref - The reference identifier that serves as the root for pruning definitions.
- * @return {JSONSchema7} - A new JSON schema object with pruned definitions.
- */
-export function pruneSchemaDefinitions(schema, ref) {
-    if (!schema.definitions) {
-        throw new Error('Schema does not have definitions');
-    }
-    const references = new Set();
-    const visited = new Set();
-    const addToReferences = (ref) => {
-        const definitionKey = getDefinitionKey(ref);
-        if (visited.has(definitionKey)) {
-            return;
-        }
-        visited.add(definitionKey);
-        references.add(definitionKey);
-        const refDef = schema.definitions?.[definitionKey];
-        if (refDef && isSchema(refDef)) {
-            collectRefs(refDef, definitionKey, addToReferences);
-        }
-    };
-    addToReferences(ref);
-    const newDefinitions = {};
-    for (const ref of references) {
-        const def = schema.definitions?.[ref];
-        if (def) {
-            newDefinitions[ref] = def;
-        }
-    }
-    return {
-        ...schema,
-        definitions: newDefinitions
-    };
-}
-/**
- * Promotes a specific object schema definition within a JSON Schema, potentially simplifying the schema
- * by focusing on the desired object and pruning unused definitions.
- *
- * Note this does not support promoting schemas that are self-referential
- *
- * @param {JSONSchema7} schema - The full JSON Schema to process.
- * @param {string} ref - The reference string identifying the target object schema within the definitions.
- * @return {ObjectSchemaWithProperties} The promoted object schema along with pruned definitions.
- * @throws {Error} If the specified reference does not correspond to a valid object definition within the schema.
- */
-export function promoteObjectSchema(schema, ref) {
-    const key = getDefinitionKey(ref);
-    const definition = schema.definitions?.[key];
-    if (!definition || !isObjectSchemaWithProperties(definition)) {
-        throw new Error(`Could not find object definition for ${ref}`);
-    }
-    const prunedSchema = pruneSchemaDefinitions(schema, ref);
-    const { [key]: _, ...rest } = prunedSchema.definitions;
-    return {
-        ...definition,
-        definitions: rest
-    };
-}

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

@@ -1,18 +0,0 @@
-import type { JSONSchema7Definition } from 'json-schema';
-import type { AllOfSchema, AnyOfSchema, ArraySchema, ConstSchema, EnumSchema, ListSchema, ObjectSchema, ObjectSchemaWithProperties, OneOfSchema, PrimitiveSchema, RefSchema, TupleSchema, TypeUnionSchema } from './types.ts';
-export declare function isBooleanProperty(schema: JSONSchema7Definition): schema is boolean;
-export declare function isSchema(schema: JSONSchema7Definition): schema is Exclude<JSONSchema7Definition, boolean>;
-export declare function isOneOfSchema(schema: JSONSchema7Definition): schema is OneOfSchema;
-export declare function isAnyOfSchema(schema: JSONSchema7Definition): schema is AnyOfSchema;
-export declare function isAllOfSchema(schema: JSONSchema7Definition): schema is AllOfSchema;
-export declare function isUnionSchema(schema: JSONSchema7Definition): schema is OneOfSchema | AnyOfSchema | AllOfSchema;
-export declare function isObjectSchema(schema: JSONSchema7Definition): schema is ObjectSchema;
-export declare function isObjectSchemaWithProperties(schema: JSONSchema7Definition): schema is ObjectSchemaWithProperties;
-export declare function isArraySchema(schema: JSONSchema7Definition): schema is ArraySchema;
-export declare function isListSchema(schema: JSONSchema7Definition): schema is ListSchema;
-export declare function isTupleSchema(schema: JSONSchema7Definition): schema is TupleSchema;
-export declare function isEnumSchema(schema: JSONSchema7Definition): schema is EnumSchema;
-export declare function isConstSchema(schema: JSONSchema7Definition): schema is ConstSchema;
-export declare function isRefSchema(schema: JSONSchema7Definition): schema is RefSchema;
-export declare function isTypeUnionSchema(schema: JSONSchema7Definition): schema is TypeUnionSchema;
-export declare function isPrimitiveSchema(schema: JSONSchema7Definition): schema is PrimitiveSchema;

package/dist/utils/type-utils.js

@@ -1,55 +0,0 @@
-import { jsonSchema7PrimitiveTypes } from "./constants.js";
-export function isBooleanProperty(schema) {
-    return typeof schema === 'boolean';
-}
-export function isSchema(schema) {
-    return !isBooleanProperty(schema);
-}
-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 isObjectSchemaWithProperties(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 isConstSchema(schema) {
-    return Boolean(isSchema(schema) && schema.const);
-}
-export function isRefSchema(schema) {
-    return Boolean(isSchema(schema) && schema.$ref);
-}
-export function isTypeUnionSchema(schema) {
-    return isSchema(schema) && Array.isArray(schema.type);
-}
-export function isPrimitiveSchema(schema) {
-    if (typeof schema !== 'object') {
-        return false;
-    }
-    if (isTypeUnionSchema(schema)) {
-        return schema.type.every((t) => jsonSchema7PrimitiveTypes.includes(t));
-    }
-    return jsonSchema7PrimitiveTypes.includes(schema.type);
-}