@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/json-schema/import.js

@@ -0,0 +1,865 @@
+/**
+ * Not from upstream: the conversion of JSON Schemas (drafts 04 to 2020-12) and OpenAPI 3.0/3.1 schema objects into
+ * schemas (lakutata's own). The schemas validate like JSON Schema: without conversion, the unknown keys as the
+ * additional properties say, the formats like the full formats of ajv-formats; the defaults are applied.
+ */
+import Engine from '../schema/index.js';
+import { FLOAT_MAX, integerTypes } from '../schema/types/number.js';
+import { formats } from '../schema/formats.js';
+import { SchemaConversionException } from '../../exceptions/SchemaConversionException.js';
+/**
+ * The JSON types
+ */
+const JSON_TYPES = ['null', 'boolean', 'number', 'integer', 'string', 'array', 'object'];
+/**
+ * The keywords of each type
+ */
+const TYPE_KEYWORDS = {
+    string: ['minLength', 'maxLength', 'pattern', 'format'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'format'],
+    array: ['items', 'prefixItems', 'additionalItems', 'contains', 'minContains', 'maxContains', 'minItems', 'maxItems', 'uniqueItems'],
+    object: ['properties', 'required', 'patternProperties', 'additionalProperties', 'propertyNames', 'minProperties', 'maxProperties', 'dependentRequired', 'dependencies']
+};
+/**
+ * The keywords which annotate a JSON Schema
+ */
+const ANNOTATION_KEYWORDS = ['title', 'description', 'default', 'examples', 'example', 'deprecated', 'readOnly', 'writeOnly', '$comment'];
+/**
+ * The keywords holding values, not schemas
+ */
+const VALUE_KEYWORDS = ['enum', 'const', 'default', 'examples', 'example'];
+/**
+ * The URI of a JSON Schema without $id
+ */
+const DEFAULT_BASE = 'https://lakutata.invalid/schema.json';
+/**
+ * The dialects of the $schema URIs
+ */
+const DIALECTS = [
+    [/draft-04/, 'draft-04'],
+    [/draft-06/, 'draft-06'],
+    [/draft-07/, 'draft-07'],
+    [/2019-09/, 'draft-2019-09'],
+    [/2020-12/, 'draft-2020-12'],
+    [/oas\/3\.1/, 'openapi-3.1']
+];
+/**
+ * Whether a value is a JSON Schema object
+ * @param value
+ */
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Whether a value is a JSON Schema
+ * @param value
+ */
+function isSchema(value) {
+    return typeof value === 'boolean' || isObject(value);
+}
+/**
+ * The URI without its fragment
+ * @param uri
+ */
+function withoutFragment(uri) {
+    const index = uri.indexOf('#');
+    return index < 0 ? uri : uri.slice(0, index);
+}
+/**
+ * Resolves a URI reference against a base URI
+ * @param reference
+ * @param base
+ */
+function resolveUri(reference, base) {
+    try {
+        return new URL(reference, base).href;
+    }
+    catch {
+        return reference;
+    }
+}
+/**
+ * A schema which no value matches
+ */
+function never() {
+    return Engine.alternatives().try(Engine.any()).match('none');
+}
+/**
+ * The schema of the values all the schemas accept: the first schema with the others as allOf (a schema with valid or
+ * allowed values accepts them without its rules: the others are the allOf of any())
+ * @param schemas
+ */
+function all(schemas) {
+    if (schemas.length === 1)
+        return schemas[0];
+    if (schemas[0]._valids)
+        return Engine.any().allOf(...schemas);
+    return schemas[0].allOf(...schemas.slice(1));
+}
+/**
+ * The schema of JSON values (arrays are not valid() arguments: they are matched item by item)
+ * @param values
+ */
+function literals(values) {
+    const scalars = values.filter((value) => !Array.isArray(value));
+    const arrays = values.filter((value) => Array.isArray(value));
+    const schemas = arrays.map((value) => {
+        const array = Engine.array().length(value.length);
+        return value.length ? array.ordered(...value.map((item) => literals([item]))) : array;
+    });
+    if (scalars.length)
+        schemas.unshift(Engine.any().valid(...scalars));
+    if (!schemas.length)
+        return never();
+    return schemas.length === 1 ? schemas[0] : Engine.alternatives().try(...schemas);
+}
+/**
+ * Converts JSON Schemas into schemas
+ */
+class Importer {
+    constructor(root, options) {
+        this.root = root;
+        //The schema resources and the anchors, by URI
+        this.registry = new Map();
+        //The converted schemas (the targets of references), by JSON Schema
+        this.converted = new Map();
+        //The references being converted: their ids, and whether they are used (a recursion)
+        this.pending = new Map();
+        //The recursive schemas, shared by the root
+        this.shared = [];
+        //The converted JSON Schema objects
+        this.memo = new WeakMap();
+        this.ids = 0;
+        this.usedIds = new Set();
+        const declared = isObject(root) ? root.$schema : undefined;
+        let dialect = options.dialect;
+        if (!dialect && typeof declared === 'string') {
+            dialect = DIALECTS.find(([pattern]) => pattern.test(declared))?.[1];
+        }
+        this.dialect = dialect || 'draft-2020-12';
+        this.convert = !!options.convert;
+        const document = options.document === undefined ? root : options.document;
+        if (isSchema(document))
+            this.register(document, DEFAULT_BASE);
+        //The document may not be a schema (an OpenAPI document): it is its resource
+        if (!isSchema(document) && document !== null && typeof document === 'object')
+            this.registry.set(DEFAULT_BASE, { node: document, base: DEFAULT_BASE });
+        for (const [uri, schema] of Object.entries(options.schemas || {})) {
+            if (isSchema(schema))
+                this.register(schema, resolveUri(uri, DEFAULT_BASE));
+        }
+    }
+    /**
+     * The schema of the root
+     */
+    run() {
+        let schema = this.node(this.root, DEFAULT_BASE);
+        for (const shared of this.shared)
+            schema = schema.shared(shared);
+        return schema.prefs({ convert: this.convert });
+    }
+    /**
+     * The id keyword of the version
+     */
+    get idKeyword() {
+        return this.dialect === 'draft-04' || this.dialect === 'openapi-3.0' ? 'id' : '$id';
+    }
+    /**
+     * Registers the resources (the schemas with an id) and the anchors of a JSON Schema
+     * @param node
+     * @param base
+     */
+    register(node, base) {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                this.register(item, base);
+            return;
+        }
+        if (!isObject(node))
+            return;
+        const id = node[this.idKeyword];
+        if (typeof id === 'string' && !id.startsWith('#')) {
+            base = resolveUri(id, base);
+            this.registry.set(withoutFragment(base), { node, base });
+        }
+        if (!this.registry.has(withoutFragment(base)))
+            this.registry.set(withoutFragment(base), { node, base });
+        //Anchors: $anchor and $dynamicAnchor, and the plain name fragments of the ids of the older versions
+        for (const anchor of [node.$anchor, node.$dynamicAnchor, typeof id === 'string' && id.startsWith('#') ? id.slice(1) : undefined]) {
+            if (typeof anchor === 'string' && anchor)
+                this.registry.set(`${withoutFragment(base)}#${anchor}`, { node, base });
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (VALUE_KEYWORDS.includes(key))
+                continue;
+            if (value !== null && typeof value === 'object')
+                this.register(value, base);
+        }
+    }
+    /**
+     * Resolves a reference
+     * @param reference
+     * @param base
+     */
+    resolve(reference, base) {
+        const uri = resolveUri(reference, base);
+        const hashIndex = uri.indexOf('#');
+        const fragment = hashIndex < 0 ? '' : decodeURIComponent(uri.slice(hashIndex + 1));
+        const resource = this.registry.get(withoutFragment(uri));
+        if (!fragment.startsWith('/') && fragment) {
+            const anchored = this.registry.get(uri);
+            if (anchored)
+                return anchored;
+        }
+        if (!resource)
+            throw new SchemaConversionException(`Cannot resolve the reference ${reference}`);
+        if (!fragment)
+            return resource;
+        if (!fragment.startsWith('/'))
+            throw new SchemaConversionException(`Cannot resolve the reference ${reference}`);
+        let target = resource.node;
+        for (const token of fragment.slice(1).split('/')) {
+            const key = token.replace(/~1/g, '/').replace(/~0/g, '~');
+            if (target === null || typeof target !== 'object' || !Object.prototype.hasOwnProperty.call(target, key))
+                throw new SchemaConversionException(`Cannot resolve the reference ${reference}`);
+            target = target[key];
+        }
+        if (!isSchema(target))
+            throw new SchemaConversionException(`The reference ${reference} is not a schema`);
+        return { node: target, base: resource.base };
+    }
+    /**
+     * The id of the shared schema of a recursive reference: the last name of the reference (unique)
+     * @param reference
+     */
+    idOf(reference) {
+        const fragment = reference.slice(reference.indexOf('#') + 1);
+        const name = decodeURIComponent(fragment.split('/').pop() || '').replace(/~1/g, '/').replace(/~0/g, '~').replace(/[^\w-]/g, '_') || 'schema';
+        let id = name;
+        while (this.usedIds.has(id))
+            id = `${name}_${++this.ids}`;
+        this.usedIds.add(id);
+        return id;
+    }
+    /**
+     * The schema of a reference (a link for a recursion)
+     * @param reference
+     * @param base
+     */
+    reference(reference, base) {
+        const { node, base: targetBase } = this.resolve(reference, base);
+        const converted = this.converted.get(node);
+        if (converted)
+            return converted;
+        const pending = this.pending.get(node);
+        if (pending) {
+            pending.used = true;
+            return Engine.link(`#${pending.id}`);
+        }
+        const id = this.idOf(reference);
+        this.pending.set(node, { id, used: false });
+        let schema = this.node(node, targetBase);
+        const { used } = this.pending.get(node);
+        this.pending.delete(node);
+        if (used) {
+            //A recursive schema is shared by the root, and referred to by links
+            this.shared.push(schema.id(id));
+            schema = Engine.link(`#${id}`);
+        }
+        this.converted.set(node, schema);
+        return schema;
+    }
+    /**
+     * Converts a JSON Schema
+     * @param node
+     * @param base
+     */
+    node(node, base) {
+        if (node === true)
+            return Engine.any();
+        if (node === false)
+            return never();
+        if (!isObject(node))
+            throw new SchemaConversionException('A JSON Schema must be an object or a boolean');
+        const memo = this.memo.get(node);
+        if (memo)
+            return memo;
+        const schema = this.convertNode(node, base);
+        this.memo.set(node, schema);
+        return schema;
+    }
+    /**
+     * Converts a JSON Schema object
+     * @param node
+     * @param base
+     */
+    convertNode(node, base) {
+        const id = node[this.idKeyword];
+        if (typeof id === 'string' && !id.startsWith('#'))
+            base = resolveUri(id, base);
+        //The keywords of the node first, then the subschemas (in the order of ajv), then the references: a recursion stops
+        //at a failing keyword
+        const parts = [];
+        const typed = this.typed(node, base);
+        if (typed)
+            parts.push(typed);
+        if (isSchema(node.not))
+            parts.push(Engine.alternatives().try(this.node(node.not, base)).match('none'));
+        const anyOf = this.list(node.anyOf);
+        if (anyOf.length)
+            parts.push(anyOf.length === 1 ? this.node(anyOf[0], base) : Engine.alternatives().try(...anyOf.map((subschema) => this.node(subschema, base))));
+        const oneOf = this.list(node.oneOf);
+        if (oneOf.length)
+            parts.push(Engine.alternatives().try(...oneOf.map((subschema) => this.node(subschema, base))).match('one'));
+        for (const subschema of this.list(node.allOf))
+            parts.push(this.node(subschema, base));
+        if (isSchema(node.if) && (isSchema(node.then) || isSchema(node.else))) {
+            parts.push(Engine.any().when(this.node(node.if, base), {
+                then: isSchema(node.then) ? this.node(node.then, base) : Engine.any(),
+                otherwise: isSchema(node.else) ? this.node(node.else, base) : Engine.any()
+            }));
+        }
+        for (const [key, dependency] of Object.entries(this.dependentSchemas(node))) {
+            //The schema applies to the objects with the key
+            parts.push(Engine.any().when(Engine.object({ [key]: Engine.any().required() }).unknown(), { then: this.node(dependency, base), otherwise: Engine.any() }));
+        }
+        //The siblings of $ref apply, like ajv does in every version (JSON Schema ignores them before 2019-09)
+        const reference = node.$ref ?? node.$dynamicRef ?? node.$recursiveRef;
+        if (typeof reference === 'string')
+            parts.push(this.reference(reference, base));
+        const unevaluated = this.unevaluated(node, base);
+        if (unevaluated)
+            parts.push(unevaluated);
+        let schema = this.values(node, parts);
+        schema = this.annotate(schema, node);
+        return schema;
+    }
+    /**
+     * The schemas of a list keyword
+     * @param value
+     */
+    list(value) {
+        return Array.isArray(value) ? value.filter(isSchema) : [];
+    }
+    /**
+     * The dependent schemas of an object JSON Schema (dependentSchemas, and the schemas of dependencies)
+     * @param node
+     */
+    dependentSchemas(node) {
+        const result = {};
+        for (const keyword of ['dependencies', 'dependentSchemas']) {
+            const dependencies = node[keyword];
+            if (!isObject(dependencies))
+                continue;
+            for (const [key, value] of Object.entries(dependencies)) {
+                if (isSchema(value))
+                    result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * The schema of the values a JSON Schema accepts: its enum (or const) values which match its other keywords, or
+     * all its keywords
+     * @param node
+     * @param parts
+     */
+    values(node, parts) {
+        let values;
+        if (Array.isArray(node.enum))
+            values = node.enum;
+        if (Object.prototype.hasOwnProperty.call(node, 'const'))
+            values = values ? values.filter((value) => literals([node.const]).validate(value).error === undefined) : [node.const];
+        const combined = parts.length === 0 ? undefined : all(parts);
+        if (!values)
+            return combined || Engine.any();
+        if (!values.length)
+            return never();
+        if (!combined)
+            return literals(values);
+        try {
+            //The values are constants: the ones the other keywords reject are dropped
+            return literals(values.filter((value) => combined.validate(value, { convert: this.convert }).error === undefined));
+        }
+        catch {
+            //A link which cannot be resolved yet
+            return all([literals(values), combined]);
+        }
+    }
+    /**
+     * The schema of the types of a JSON Schema, with the keywords of each type (undefined: no type constraint)
+     * @param node
+     * @param base
+     */
+    typed(node, base) {
+        let types = typeof node.type === 'string' ? [node.type] : Array.isArray(node.type) ? node.type.filter((type) => typeof type === 'string') : undefined;
+        if (types && this.dialect === 'openapi-3.0' && node.nullable === true && !types.includes('null'))
+            types = [...types, 'null'];
+        if (!types) {
+            const constrained = Object.keys(TYPE_KEYWORDS).filter((type) => TYPE_KEYWORDS[type].some((keyword) => node[keyword] !== undefined));
+            if (!constrained.length)
+                return undefined;
+            types = ['null', 'boolean', 'number', 'string', 'array', 'object'];
+        }
+        types = types.filter((type) => JSON_TYPES.includes(type));
+        //Integers are numbers
+        if (types.includes('number'))
+            types = types.filter((type) => type !== 'integer');
+        const unique = [...new Set(types)];
+        //Null is allowed besides the other types
+        const nullable = unique.length > 1 && unique.includes('null');
+        const schemas = unique.filter((type) => !nullable || type !== 'null').map((type) => this.type(type, node, base));
+        if (!schemas.length)
+            return never();
+        const schema = schemas.length === 1 ? schemas[0] : Engine.alternatives().try(...schemas);
+        return nullable ? schema.allow(null) : schema;
+    }
+    /**
+     * The schema of a type, with its keywords
+     * @param type
+     * @param node
+     * @param base
+     */
+    type(type, node, base) {
+        switch (type) {
+            case 'null':
+                return Engine.any().valid(null);
+            case 'boolean':
+                return Engine.boolean();
+            case 'integer':
+            case 'number':
+                return this.number(node, type === 'integer');
+            case 'string':
+                return this.string(node);
+            case 'array':
+                return this.array(node, base);
+            default:
+                return this.object(node, base);
+        }
+    }
+    /**
+     * The schema of the numbers of a JSON Schema
+     * @param node
+     * @param integer
+     */
+    number(node, integer) {
+        let schema = Engine.number().unsafe();
+        let minimum = typeof node.minimum === 'number' ? node.minimum : undefined;
+        let maximum = typeof node.maximum === 'number' ? node.maximum : undefined;
+        let greater = typeof node.exclusiveMinimum === 'number' ? node.exclusiveMinimum : undefined;
+        let less = typeof node.exclusiveMaximum === 'number' ? node.exclusiveMaximum : undefined;
+        //Draft 04 (and OpenAPI 3.0): boolean exclusive bounds
+        if (node.exclusiveMinimum === true && minimum !== undefined) {
+            greater = minimum;
+            minimum = undefined;
+        }
+        if (node.exclusiveMaximum === true && maximum !== undefined) {
+            less = maximum;
+            maximum = undefined;
+        }
+        const format = node.format;
+        //The numeric types: the formats (as ajv-formats validates them), and the bounds of the integer types
+        const typeName = typeof format === 'string' && ['int32', 'int64', 'float', 'double'].includes(format) ? format :
+            integer ? Object.keys(integerTypes).find((name) => integerTypes[name][0] === minimum && integerTypes[name][1] === maximum) :
+                minimum === -FLOAT_MAX && maximum === FLOAT_MAX ? 'float' : undefined;
+        if (typeName) {
+            schema = schema[typeName].call(schema);
+            if (typeName in integerTypes || typeName === 'float') {
+                const [low, high] = typeName === 'float' ? [-FLOAT_MAX, FLOAT_MAX] : integerTypes[typeName];
+                //The type bounds are not repeated
+                if (minimum === low)
+                    minimum = undefined;
+                if (maximum === high)
+                    maximum = undefined;
+            }
+        }
+        if (integer && !(typeName && typeName in integerTypes))
+            schema = schema.integer();
+        if (minimum !== undefined)
+            schema = schema.min(minimum);
+        if (maximum !== undefined)
+            schema = schema.max(maximum);
+        if (greater !== undefined)
+            schema = schema.greater(greater);
+        if (less !== undefined)
+            schema = schema.less(less);
+        if (typeof node.multipleOf === 'number' && node.multipleOf > 0)
+            schema = schema.multiple(node.multipleOf);
+        return schema;
+    }
+    /**
+     * The schema of the strings of a JSON Schema
+     * @param node
+     */
+    string(node) {
+        //A minimum length (of zero at least) makes the empty string valid
+        let schema = Engine.string().min(typeof node.minLength === 'number' ? node.minLength : 0);
+        if (typeof node.maxLength === 'number')
+            schema = schema.max(node.maxLength);
+        if (typeof node.pattern === 'string') {
+            let regex;
+            try {
+                regex = new RegExp(node.pattern, 'u');
+            }
+            catch {
+                throw new SchemaConversionException(`Invalid pattern: ${node.pattern}`);
+            }
+            schema = schema.pattern(regex);
+        }
+        const format = node.format;
+        if (typeof format === 'string' && Object.prototype.hasOwnProperty.call(formats, format))
+            schema = schema.format(format);
+        return schema;
+    }
+    /**
+     * The schema of the arrays of a JSON Schema
+     * @param node
+     * @param base
+     */
+    array(node, base) {
+        let schema = Engine.array();
+        //The ordered items: prefixItems (2020-12), or an items array (before)
+        const prefix = Array.isArray(node.prefixItems) ? this.list(node.prefixItems) : Array.isArray(node.items) ? this.list(node.items) : undefined;
+        const rest = prefix ? (Array.isArray(node.prefixItems) ? node.items : node.additionalItems) : node.items;
+        let maxItems = typeof node.maxItems === 'number' ? node.maxItems : undefined;
+        if (prefix && prefix.length)
+            schema = schema.ordered(...prefix.map((item) => this.node(item, base)));
+        if (rest === false) {
+            //No other items
+            const length = prefix ? prefix.length : 0;
+            if (!prefix || !prefix.length)
+                maxItems = maxItems === undefined ? length : Math.min(maxItems, length);
+        }
+        else if (isSchema(rest) && rest !== true) {
+            schema = schema.items(this.node(rest, base));
+        }
+        else if (prefix && prefix.length) {
+            schema = schema.items(Engine.any());
+        }
+        if (typeof node.minItems === 'number')
+            schema = schema.min(node.minItems);
+        if (maxItems !== undefined)
+            schema = schema.max(maxItems);
+        if (node.uniqueItems === true)
+            schema = schema.unique();
+        if (isSchema(node.contains)) {
+            const min = typeof node.minContains === 'number' ? node.minContains : 1;
+            const max = typeof node.maxContains === 'number' ? node.maxContains : undefined;
+            //More matches than possible: no array
+            if (max !== undefined && min > max)
+                return never();
+            schema = schema.has(this.node(node.contains, base), min === 1 && max === undefined ? {} : { min, max });
+        }
+        return schema;
+    }
+    /**
+     * The schema of the objects of a JSON Schema
+     * @param node
+     * @param base
+     */
+    object(node, base) {
+        return this.refineObject(Engine.object(this.objectKeys(node, base)), node, base);
+    }
+    /**
+     * The pattern properties of an object JSON Schema
+     * @param node
+     * @param base
+     */
+    objectPatterns(node, base) {
+        const patterns = [];
+        if (!isObject(node.patternProperties))
+            return patterns;
+        for (const [source, subschema] of Object.entries(node.patternProperties)) {
+            if (!isSchema(subschema))
+                continue;
+            let regex;
+            try {
+                regex = new RegExp(source, 'u');
+            }
+            catch {
+                throw new SchemaConversionException(`Invalid pattern: ${source}`);
+            }
+            patterns.push({ regex, schema: this.node(subschema, base) });
+        }
+        return patterns;
+    }
+    /**
+     * The schemas of the keys of an object JSON Schema: its properties and its required keys
+     * @param node
+     * @param base
+     */
+    objectKeys(node, base) {
+        const properties = isObject(node.properties) ? node.properties : {};
+        const required = Array.isArray(node.required) ? node.required.filter((key) => typeof key === 'string') : [];
+        const patterns = this.objectPatterns(node, base);
+        const additional = node.additionalProperties;
+        const keys = {};
+        for (const key of new Set([...Object.keys(properties), ...required])) {
+            //The patterns apply to the properties too
+            const matching = patterns.filter(({ regex }) => regex.test(key)).map(({ schema }) => schema);
+            const schemas = [...isSchema(properties[key]) ? [this.node(properties[key], base)] : [], ...matching];
+            //A required key which is not a property, nor matches a pattern, is an additional property
+            if (!isSchema(properties[key]) && !matching.length && isSchema(additional) && additional !== true)
+                schemas.push(this.node(additional, base));
+            const schema = schemas.length === 0 ? Engine.any() : all(schemas);
+            keys[key] = required.includes(key) ? schema.required() : schema.optional();
+        }
+        return keys;
+    }
+    /**
+     * Adds the keywords of an object JSON Schema, but its keys, to an object schema
+     * @param schema
+     * @param node
+     * @param base
+     */
+    refineObject(schema, node, base) {
+        for (const { regex, schema: patternSchema } of this.objectPatterns(node, base))
+            schema = schema.pattern(regex, patternSchema, { fallthrough: true });
+        const additional = node.additionalProperties;
+        if (additional === false) {
+            schema = schema.unknown(false);
+        }
+        else if (isSchema(additional) && additional !== true) {
+            schema = schema.unknown(this.node(additional, base));
+        }
+        else {
+            schema = schema.unknown(true);
+        }
+        if (isSchema(node.propertyNames))
+            schema = schema.keyNames(this.node(node.propertyNames, base));
+        if (typeof node.minProperties === 'number')
+            schema = schema.min(node.minProperties);
+        if (typeof node.maxProperties === 'number')
+            schema = schema.max(node.maxProperties);
+        for (const keyword of ['dependencies', 'dependentRequired']) {
+            const dependencies = node[keyword];
+            if (!isObject(dependencies))
+                continue;
+            for (const [key, peers] of Object.entries(dependencies)) {
+                if (Array.isArray(peers) && peers.length)
+                    schema = schema.with(key, peers.filter((peer) => typeof peer === 'string'));
+            }
+        }
+        return schema;
+    }
+    /**
+     * The parts of an object JSON Schema (the root) for the classes of objects: the schemas of its keys, and its other
+     * keywords, as the refinement of an object schema made of the keys
+     */
+    objectParts() {
+        let node = this.root;
+        let base = DEFAULT_BASE;
+        //A reference to an object JSON Schema
+        while (isObject(node) && typeof node.$ref === 'string' && Object.keys(node).every((key) => key === '$ref' || ANNOTATION_KEYWORDS.includes(key))) {
+            const annotations = node;
+            const resolved = this.resolve(node.$ref, base);
+            node = isObject(resolved.node) ? { ...annotations, ...resolved.node } : resolved.node;
+            delete node.$ref;
+            if (isObject(resolved.node) && typeof resolved.node.$ref === 'string')
+                node.$ref = resolved.node.$ref;
+            base = resolved.base;
+        }
+        if (!isObject(node))
+            throw new SchemaConversionException('The JSON Schema of a DTO must describe objects');
+        const types = node.type;
+        if (types !== undefined && !(types === 'object' || Array.isArray(types) && types.includes('object')))
+            throw new SchemaConversionException('The JSON Schema of a DTO must describe objects');
+        const id = node[this.idKeyword];
+        if (typeof id === 'string' && !id.startsWith('#'))
+            base = resolveUri(id, base);
+        const object = node;
+        const keys = this.objectKeys(object, base);
+        //The other keywords: the subschemas, the references, the values
+        const { type, properties, required, patternProperties, additionalProperties, propertyNames, minProperties, maxProperties, dependentRequired, ...rest } = object;
+        const others = Object.fromEntries(Object.entries(rest).filter(([key]) => !TYPE_KEYWORDS.string.includes(key) && !TYPE_KEYWORDS.number.includes(key) && !TYPE_KEYWORDS.array.includes(key)));
+        //The array form of dependencies is a key dependency of the object
+        if (isObject(others.dependencies))
+            others.dependencies = Object.fromEntries(Object.entries(others.dependencies).filter(([, value]) => isSchema(value)));
+        const hasOthers = Object.keys(others).some((key) => !ANNOTATION_KEYWORDS.includes(key) && !['$schema', '$id', 'id', '$defs', 'definitions', '$comment', 'nullable', 'discriminator', 'xml', 'externalDocs'].includes(key));
+        //The unevaluated keywords evaluate the keys with the properties: the whole JSON Schema is the constraint
+        const constraint = !hasOthers ? undefined : others.unevaluatedProperties !== undefined || others.unevaluatedItems !== undefined ? this.node(object, base) : this.node({ ...others, type: 'object' }, base);
+        const shared = this.shared;
+        const withShared = (schema) => {
+            for (const sharedSchema of shared)
+                schema = schema.shared(sharedSchema);
+            return schema;
+        };
+        for (const key of Object.keys(keys))
+            keys[key] = withShared(keys[key]);
+        return {
+            keys,
+            refine: (schema) => {
+                let refined = this.refineObject(schema, object, base);
+                if (constraint)
+                    refined = refined.allOf(constraint);
+                return withShared(refined);
+            },
+            title: typeof object.title === 'string' ? object.title : undefined,
+            description: typeof object.description === 'string' ? object.description : undefined
+        };
+    }
+    /**
+     * The keys and the item indexes of a value the keywords of a JSON Schema evaluate (its annotations): the keywords
+     * of the schema, and of its subschemas which match the value
+     * @param node
+     * @param base
+     * @param value
+     * @param helpers
+     * @param path the schemas being evaluated (a recursion without progress evaluates nothing more)
+     */
+    evaluated(node, base, value, helpers, path = new Set()) {
+        const result = { keys: new Set(), items: new Set(), all: false };
+        if (!isObject(node) || path.has(node))
+            return result;
+        path = new Set(path).add(node);
+        const id = node[this.idKeyword];
+        if (typeof id === 'string' && !id.startsWith('#'))
+            base = resolveUri(id, base);
+        const add = (sub) => {
+            sub.keys.forEach((key) => result.keys.add(key));
+            sub.items.forEach((index) => result.items.add(index));
+            result.all = result.all || sub.all;
+        };
+        const matches = (subschema) => {
+            const schema = this.node(subschema, base);
+            return schema.$_match(value, helpers.state.nest(schema, 'unevaluated'), helpers.prefs);
+        };
+        if (Array.isArray(value)) {
+            const prefix = Array.isArray(node.prefixItems) ? node.prefixItems : Array.isArray(node.items) ? node.items : undefined;
+            if (Array.isArray(prefix))
+                for (let i = 0; i < Math.min(prefix.length, value.length); ++i)
+                    result.items.add(i);
+            if ((node.items !== undefined && !Array.isArray(node.items)) || node.additionalItems !== undefined || node.unevaluatedItems !== undefined)
+                result.all = true;
+            //The items contains matches (2020-12)
+            if (isSchema(node.contains) && this.dialect !== 'draft-2019-09') {
+                const contains = this.node(node.contains, base);
+                value.forEach((item, index) => {
+                    if (contains.$_match(item, helpers.state.nest(contains, 'unevaluated'), helpers.prefs))
+                        result.items.add(index);
+                });
+            }
+        }
+        else if (isObject(value)) {
+            const keys = Object.keys(value);
+            if (isObject(node.properties)) {
+                for (const key of Object.keys(node.properties)) {
+                    if (Object.prototype.hasOwnProperty.call(value, key))
+                        result.keys.add(key);
+                }
+            }
+            if (isObject(node.patternProperties)) {
+                const patterns = Object.keys(node.patternProperties).map((pattern) => new RegExp(pattern, 'u'));
+                for (const key of keys) {
+                    if (patterns.some((regex) => regex.test(key)))
+                        result.keys.add(key);
+                }
+            }
+            if (node.additionalProperties !== undefined || node.unevaluatedProperties !== undefined)
+                result.all = true;
+            for (const [key, dependency] of Object.entries(this.dependentSchemas(node))) {
+                if (Object.prototype.hasOwnProperty.call(value, key) && matches(dependency))
+                    add(this.evaluated(dependency, base, value, helpers, path));
+            }
+        }
+        for (const subschema of this.list(node.allOf))
+            add(this.evaluated(subschema, base, value, helpers, path));
+        for (const subschema of [...this.list(node.anyOf), ...this.list(node.oneOf)]) {
+            if (matches(subschema))
+                add(this.evaluated(subschema, base, value, helpers, path));
+        }
+        if (isSchema(node.if)) {
+            if (matches(node.if)) {
+                add(this.evaluated(node.if, base, value, helpers, path));
+                if (isSchema(node.then))
+                    add(this.evaluated(node.then, base, value, helpers, path));
+            }
+            else if (isSchema(node.else)) {
+                add(this.evaluated(node.else, base, value, helpers, path));
+            }
+        }
+        const reference = node.$ref ?? node.$dynamicRef ?? node.$recursiveRef;
+        if (typeof reference === 'string') {
+            const target = this.resolve(reference, base);
+            add(this.evaluated(target.node, target.base, value, helpers, path));
+        }
+        return result;
+    }
+    /**
+     * The schema of unevaluatedProperties and unevaluatedItems: the keys and the items the keywords of the JSON Schema
+     * (and of its subschemas which match the value) do not evaluate must match them
+     * @param node
+     * @param base
+     */
+    unevaluated(node, base) {
+        const { unevaluatedProperties, unevaluatedItems, ...rest } = node;
+        const properties = isSchema(unevaluatedProperties) && unevaluatedProperties !== true ? this.node(unevaluatedProperties, base) : undefined;
+        const items = isSchema(unevaluatedItems) && unevaluatedItems !== true ? this.node(unevaluatedItems, base) : undefined;
+        if (!properties && !items)
+            return undefined;
+        return Engine.any().custom((value, helpers) => {
+            const isArray = Array.isArray(value);
+            if (isArray ? !items : !properties || !isObject(value))
+                return value;
+            const evaluated = this.evaluated(rest, base, value, helpers);
+            if (evaluated.all)
+                return value;
+            const schema = (isArray ? items : properties);
+            const entries = isArray ? value.map((item, index) => [index, item]) : Object.entries(value);
+            for (const [key, item] of entries) {
+                if (isArray ? evaluated.items.has(key) : evaluated.keys.has(key))
+                    continue;
+                if (!schema.$_match(item, helpers.state.nest(schema, 'unevaluated'), helpers.prefs)) {
+                    return helpers.message({ custom: `{{#label}} has an unevaluated ${isArray ? 'item' : 'key'} {{#name}} which is not allowed` }, { name: key });
+                }
+            }
+            return value;
+        }, 'unevaluated keys and items');
+    }
+    /**
+     * Adds the annotations of a JSON Schema
+     * @param schema
+     * @param node
+     */
+    annotate(schema, node) {
+        if (typeof node.description === 'string' && node.description)
+            schema = schema.description(node.description);
+        if (node.default !== undefined)
+            schema = schema.default(node.default);
+        const examples = Array.isArray(node.examples) ? node.examples : node.example !== undefined ? [node.example] : [];
+        for (const example of examples)
+            schema = schema.example(example);
+        const meta = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (['title', 'deprecated', 'readOnly', 'writeOnly', 'contentEncoding', 'contentMediaType'].includes(key) || key.startsWith('x-'))
+                meta[key] = value;
+        }
+        //The formats which are not validated are annotations
+        if (typeof node.format === 'string' && !Object.prototype.hasOwnProperty.call(formats, node.format) && !['int32', 'int64', 'float', 'double'].includes(node.format))
+            meta.format = node.format;
+        if (Object.keys(meta).length)
+            schema = schema.meta(meta);
+        return schema;
+    }
+}
+/**
+ * Converts a JSON Schema (or an OpenAPI schema object) into a schema
+ * @param schema
+ * @param options
+ */
+export function fromJsonSchema(schema, options = {}) {
+    if (!isSchema(schema))
+        throw new SchemaConversionException('A JSON Schema must be an object or a boolean');
+    return new Importer(schema, options).run();
+}
+/**
+ * Converts an object JSON Schema (or an OpenAPI schema object) into the parts of a class of objects (a DTO): the
+ * schemas of its keys, and its other keywords as the refinement of an object schema
+ * @param schema
+ * @param options
+ */
+export function importObject(schema, options = {}) {
+    if (!isSchema(schema))
+        throw new SchemaConversionException('A JSON Schema must be an object or a boolean');
+    return new Importer(schema, options).objectParts();
+}