Schema

the keywords holding a text for humans, translated (jsonSerialize, Translate)

Type

array

Add $key to the 'required' list (a no-op if it's already there).

Coerce $value to match this schema's declared type(s), trying each in turn (Coercer::Coerce) -- 'enum'/'const' take priority (coerced to match one of the allowed values), 'instanceOf' adds the 'instance' type, and an untyped-but-structured schema ('properties' implies 'object', 'items'/'prefixItems' implies 'array') is coerced accordingly; a schema with no type information at all is left untouched.

Build the right Validator subclass for $value, based on this schema's declared 'type' (or, if none, $value's own PHP type -- see typeOf).

Create a list of definition schema from a list of classes.

Same as Container::Fetch, ensuring the built-in global types (InitGlobalTypes) are registered first.

Build a schema from a flexible, convenient input.

Create a schema from an enum: its enum keyword lists a backed enum's values, or a pure enum's case names (what tryEnumFrom reads back and aExporter::exportEnum writes).

Same as Container::get, also checking the root schema's $anchor-registered sub-schemas (setContent) first.

Get schema default value.

Collect every class/interface name this schema (and, per $recursive, its sub-schemas) could produce via 'instanceOf' -- used e.g. by Defs to discover which classes' own schemas need registering.

Get the schema at the given path

Get the schema for an object path (using 'properties' or 'items' sub schemas)

Same as getLabel, for the 'title' keyword (falling back to getLabel if there's no 'title').

Get all the readable properties

NOTE: this used to check $this->anchors -- but anchors are only ever registered on the ROOT schema's

Voir

$anchors (setContent), same as get() correctly checks via $this->getRoot()->anchors. So has() only ever worked when called directly on the root; called on any nested sub-schema, it always missed an anchor that get() itself could find on that very same schema. Fixed to match get()'s own logic.

Tells if schema has a default value

Register the bare {"type": "..."} schema for each of TYPES globally, once. Called automatically wherever a global schema might be looked up (GlobalTypes/Fetch).

Test if schema represents a datetime

Test if schema is an instance of a class

NOTE: this used to omit the ??[] fallback that every other 'type'-array check in this class uses (e.g.

Voir

isList/isObject/isString), so a schema with no 'type' keyword at all (a completely valid, common case -- e.g. a bare {"enum": [...]}) crashed with a TypeError instead of correctly answering "not nullable". Fixed to match the established pattern.

The schema for json_encode(), its human texts (I18N_KEYWORDS: title, label, description) translated in the current language (Translate): a schema's texts are English keys, the front shows them in the user's language. Only these keywords, never enum values nor property names. Every sub-schema is a Schema instance (mutate), which translates its own texts when it is exported in turn: each text is translated once.

Voir

iMutationObserver hook, invoked whenever a schema property is set/changed (including once for every top-level keyword right after setContent loads new content). Keeps this schema's internal invariants: schema-shaped properties (SCHEMA_PROPERTY/SCHEMAS_PROPERTY) are normalized into real Schema/, TrueSchema/FalseSchema instances (via From) as soon as they're set; 'type' is re-normalized (setType); a scalar 'instanceOf' is wrapped into a single-element array; and, on deletion, a removed sub-schema's anchor (if any) is unregistered from the root.

Render one value for a {placeholder} in getLabel/getTitle's templates: an iEntity's title, a backed enum's value, a pure enum's name (what FromEnum lists), a date as 'd/m/Y', or its plain string cast otherwise.

Register a custom named schema globally, reachable afterward via its TypeId (e.g. by $ref).

Resolve a JSON Schema $ref (or any URI) to the schema it points to.

Get the schema associated to the first instanceOf

Load raw schema data: sets $id/registers an $anchor/$dynamicAnchor on the root, converts a $dynamicRef to a plain $ref (dynamic refs aren't otherwise supported), triggers mutate for every top-level keyword (so schema-shaped properties -- SCHEMA_PROPERTY/SCHEMAS_PROPERTY -- are converted into actual Schema/TrueSchema/FalseSchema instances), then, if a root-level $ref is present, resolves and merges it in (a $ref alongside other keywords -- unlike From's lone-$ref shortcut -- augments this schema rather than replacing it).

Set the type

Order the keys of an array using the properties order

The path a repository stores what $path names: each alias on the way (a property whose getter is a json-path, #[ArrayProperty(name: 'adresse', getter: '/adresses/default')]) replaced by the path it reads. A filter or a sort on an alias is run on that one (Query::execute): a repository knows nothing of the alias.

Build a regular expression matching (roughly) the same values this schema would accept -- useful e.g. for a route parameter pattern.

Validate a value through this schema

Walk through all the schema in a path, resolving the instanceOf on the way.