@kollors/deep-json-server 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/src/core/lifecycle/options.d.ts

@@ -0,0 +1,21 @@
+export interface RecordOptions {
+    timestamps?: boolean;
+    softDelete?: boolean;
+    auth?: boolean;
+}
+export interface Actor {
+    id: string;
+    isAdmin?: boolean;
+}
+export type ActorSource = Actor | (() => Actor);
+export type Authenticate = (authorization: unknown) => Actor;
+export declare const DELETION_META = "djsDeletion";
+export declare const AUDIT_FIELDS: readonly ['createdAt', 'updatedAt', 'deletedAt', 'createdById', 'updatedById', 'deletedById'];
+/** Проверяет логические флаги и заменяет отсутствующие значения на false.
+ * @example recordOptions({ softDelete: true }) → { timestamps: false, softDelete: true, auth: false }.
+ */
+export declare function recordOptions(options?: RecordOptions): Required<RecordOptions>;
+/** Ищет условие deletedAt на текущем уровне и в логических ветках, не заходя в поля связанных объектов.
+ * @example mentionsDeletedAt({ or: [{ deletedAt: { ne: null } }] }) → true; { user: { deletedAt: {} } } → false.
+ */
+export declare function mentionsDeletedAt(where: unknown): boolean;

package/dist/src/core/lifecycle/options.js

@@ -0,0 +1,19 @@
+import { getBoolean } from '../config-values.js';
+import { isObject } from '../utils.js';
+export const DELETION_META = 'djsDeletion';
+export const AUDIT_FIELDS = ['createdAt', 'updatedAt', 'deletedAt', 'createdById', 'updatedById', 'deletedById'];
+/** Проверяет логические флаги и заменяет отсутствующие значения на false.
+ * @example recordOptions({ softDelete: true }) → { timestamps: false, softDelete: true, auth: false }.
+ */
+export function recordOptions(options = {}) {
+    return { timestamps: getBoolean(options.timestamps, 'timestamps') ?? false, softDelete: getBoolean(options.softDelete, 'softDelete') ?? false, auth: getBoolean(options.auth, 'auth') ?? false };
+}
+/** Ищет условие deletedAt на текущем уровне и в логических ветках, не заходя в поля связанных объектов.
+ * @example mentionsDeletedAt({ or: [{ deletedAt: { ne: null } }] }) → true; { user: { deletedAt: {} } } → false.
+ */
+export function mentionsDeletedAt(where) {
+    if (!isObject(where))
+        return false;
+    return Object.hasOwn(where, 'deletedAt') || ['and', 'or'].some((key) => Array.isArray(where[key]) && where[key].some(mentionsDeletedAt)) || mentionsDeletedAt(where.not);
+}
+//# sourceMappingURL=options.js.map

package/dist/src/core/lifecycle/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../src/core/lifecycle/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAavC,MAAM,CAAC,MAAM,aAAa,GAAG,aAAa,CAAC;AAC3C,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,CAAU,CAAC;AAC1H;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,OAAO,GAAkB,EAAE;IACvD,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,KAAK,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,KAAK,EAAE,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;AACnM,CAAC;AACD;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC9C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACnC,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC3K,CAAC"}

package/dist/src/core/model.d.ts

@@ -0,0 +1,145 @@
+import { type RecordOptions } from './lifecycle/options.js';
+import type { WriteMode } from './operations.js';
+import type { DatabaseData, JsonValue } from './types.js';
+export interface Field {
+    type: string;
+    description?: string;
+    example?: JsonValue;
+    required?: boolean;
+    nullable?: boolean;
+    default?: JsonValue;
+    enum?: JsonValue[];
+    primary?: boolean;
+    generated?: 'uuid' | 'increment';
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: 'date' | 'date-time' | 'email' | 'uri' | 'uuid';
+    minimum?: number;
+    maximum?: number;
+    source?: string;
+    target?: string;
+    onDelete?: 'restrict' | 'cascade';
+}
+export interface EntityDefinition {
+    timestamps?: boolean;
+    softDelete?: boolean;
+    collection: string;
+    api?: ('openapi' | 'graphql')[];
+    fields: Record<string, Field>;
+}
+export type ApiFormat = 'openapi' | 'graphql';
+export interface ModelSchema {
+    models: Record<string, EntityDefinition>;
+    api?: ApiFormat[];
+    timestamps?: boolean;
+    softDelete?: boolean;
+}
+export interface ModelOptions {
+    auth?: boolean;
+    api?: ApiFormat[];
+}
+/** Проверяет список форматов и возвращает его независимую копию.
+ * @example apiFormats(['graphql']) → ['graphql']; ['unknown'] → ошибка.
+ */
+export declare function apiFormats(value: unknown, fallback: ApiFormat[], label: string): ApiFormat[];
+export interface Node extends Field {
+    system?: boolean;
+    internal?: boolean;
+    softDelete?: boolean;
+    path: string;
+    base: string;
+    many: boolean;
+    children: Record<string, Node>;
+    relation?: Entity;
+    implicit?: boolean;
+    mixed?: boolean;
+    relationKey?: boolean;
+}
+export interface Entity {
+    timestamps: boolean;
+    softDelete: boolean;
+    name: string;
+    collection: string;
+    api: ('openapi' | 'graphql')[];
+    primary: string;
+    fields: Record<string, Node>;
+    root: Node;
+}
+export interface Model {
+    options: Required<RecordOptions>;
+    entities: Entity[];
+    byName: Map<string, Entity>;
+    byCollection: Map<string, Entity>;
+    explicit: boolean;
+}
+export type ValidationSchema = Record<string, unknown>;
+/** Разбивает путь по точкам и проверяет допустимость каждого имени.
+ * @example pathParts('profile.name') → ['profile', 'name']; pathParts('a..b') → ошибка.
+ */
+export declare const pathParts: (path: string) => string[];
+/** Находит самый длинный префикс пути среди ключей объекта, учитывая границы сегментов.
+ * @example bindingFor({ a: {}, 'a.b': {} }, 'a.b.id') → 'a.b'; bindingFor({ a: {} }, 'abc.id') → undefined.
+ */
+export declare function bindingFor(bindings: Record<string, unknown>, path: string): string | undefined;
+/** Проверяет, что все сегменты пути объявлены и доступны для записи, включая родительские объекты.
+ * @example Для поля name без ограничений canWriteKey(entity, 'name') → true; для первичного ключа → false.
+ */
+export declare function canWriteKey(entity: Entity, path: string): boolean;
+/** Распознаёт обратную связь: источник совпадает с первичным ключом, а целевой путь отличается от первичного ключа цели.
+ * @example При source = 'id', target = 'authorId' и первичных ключах id → true.
+ */
+export declare function isReverseRelation(entity: Entity, node: Node): boolean;
+/** Собирает значения по вложенному пути, проходя через массивы; отсутствующие значения и null пропускает.
+ * @example readPath({ rows: [{ id: 1 }, { id: 2 }] }, 'rows.id') → [1, 2].
+ */
+export declare const readPath: (value: unknown, path: string | string[]) => unknown[];
+/** Возвращает последний сегмент пути поля.
+ * @example childName({ path: 'profile.name', … }) → 'name'.
+ */
+export declare const childName: (node: Node) => string;
+/** Для связи возвращает целевую сущность и её корень; обычный узел сохраняет без изменений.
+ * @example canonicalNode(author, { relation: book }) → [book, book.root].
+ * @example canonicalNode(author, author.root) → [author, author.root].
+ */
+export declare const canonicalNode: (entity: Entity, node: Node) => [Entity, Node];
+/** Соединяет имя сущности и путь поля, заменяя точки подчёркиваниями.
+ * @example nodeName({ name: 'User', … }, { path: 'profile.name', … }) → 'User_profile_name'.
+ */
+export declare const nodeName: (entity: Entity, node: Node) => string;
+/** Переводит первую букву имени сущности в нижний регистр.
+ * @example operationName({ name: 'UserProfile', … }) → 'userProfile'.
+ */
+export declare const operationName: (entity: Entity) => string;
+/** Загружает описание из объекта или JSON-файла, проверяет поля и сопоставляет связи.
+ * @example loadModel(undefined) → Promise<undefined>; корректное описание → Promise<Model>.
+ */
+export declare function loadModel(source: unknown, settings?: ModelOptions): Promise<Model | undefined>;
+/** Определяет доступность поля для выбранного режима записи, учитывая защищённые дочерние поля.
+ * @example writable({ readOnly: true, … }, 'update') → false.
+ */
+export declare function writable(node: Node, mode: InputMode, relations?: boolean): boolean;
+/** Проверяет наличие явной модели и доступность выбранного формата для её связей.
+ * @example assertApi(undefined, 'graphql') → ошибка; согласованная модель → undefined.
+ */
+export declare function assertApi(model: Model | undefined, api: 'graphql' | 'openapi'): asserts model is Model;
+/** Строит схему проверки значения с ограничениями, массивом и допустимостью null.
+ * @example Для строкового узла без ограничений valueSchema(node) → { type: 'string' }.
+ */
+export declare function valueSchema(node: Node): ValidationSchema;
+export type InputMode = 'stored' | WriteMode;
+/** Строит схему объекта для выбранного режима; при частичном обновлении корневые поля необязательны.
+ * @example Для пустого узла → { type: 'object', properties: {}, additionalProperties: false }.
+ */
+export declare function objectSchema(node: Node, mode: InputMode, root?: boolean, relationSchema?: (node: Node) => ValidationSchema): ValidationSchema;
+export declare function relationInputSchema(node: Node, object?: ValidationSchema): ValidationSchema;
+/** Проверяет запись по схеме выбранного режима и выбрасывает исключение при несоответствии.
+ * @example Обязательное строковое name: { name: 'Анна' } → undefined; { name: 2 } → ошибка.
+ */
+export declare function validateRecord(entity: Entity, value: unknown, mode: InputMode, relations?: boolean): void;
+/** Выводит поля и связи из значений коллекций, не меняя переданные записи.
+ * @example inferModel({ users: [{ id: '1', name: 'Анна' }] }) → модель со строковыми id и name.
+ */
+export declare function inferModel(database: DatabaseData, settings?: RecordOptions): Model;

package/dist/src/{model.js → core/model.js}

@@ -1,10 +1,26 @@
 import { readFile } from 'node:fs/promises';
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
+import { domainError } from './errors.js';
+import { AUDIT_FIELDS, DELETION_META, recordOptions } from './lifecycle/options.js';
 import { getRelationMetadata } from './relation-metadata.js';
-import { assertKnownKeys, createHttpError, isObject, isSafeKey, singularize, toPascalCase } from './utils.js';
-export const ajv = new Ajv({ allErrors: true, coerceTypes: false, removeAdditional: false, strict: true, ownProperties: true });
-addFormats.default(ajv);
+import { assertKnownKeys, isObject, isSafeKey, singularize, toPascalCase } from './utils.js';
+/** Проверяет список форматов и возвращает его независимую копию.
+ * @example apiFormats(['graphql']) → ['graphql']; ['unknown'] → ошибка.
+ */
+export function apiFormats(value, fallback, label) {
+    if (value === undefined)
+        return [...fallback];
+    if (!Array.isArray(value) || value.some((format) => !['openapi', 'graphql'].includes(format)) || new Set(value).size !== value.length)
+        throw new Error(`Invalid api for ${label}`);
+    return [...value];
+}
+const createValidator = () => {
+    const ajv = new Ajv({ allErrors: true, coerceTypes: false, removeAdditional: false, strict: true, ownProperties: true });
+    addFormats.default(ajv);
+    return ajv;
+};
+const entityValidators = new WeakMap();
 const PRIMITIVES = new Set(['string', 'number', 'boolean', 'object']);
 const NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
 const FIELD_KEYS = new Set([
@@ -29,12 +45,44 @@ const FIELD_KEYS = new Set([
     'target',
     'onDelete',
 ]);
+/** Разбивает путь по точкам и проверяет допустимость каждого имени.
+ * @example pathParts('profile.name') → ['profile', 'name']; pathParts('a..b') → ошибка.
+ */
 export const pathParts = (path) => {
     const parts = path.split('.');
     if (parts.some((p) => !NAME.test(p) || !isSafeKey(p)))
-        throw createHttpError(400, `Invalid field path: ${path}`);
+        throw domainError('INVALID_INPUT', `Invalid field path: ${path}`);
     return parts;
 };
+/** Находит самый длинный префикс пути среди ключей объекта, учитывая границы сегментов.
+ * @example bindingFor({ a: {}, 'a.b': {} }, 'a.b.id') → 'a.b'; bindingFor({ a: {} }, 'abc.id') → undefined.
+ */
+export function bindingFor(bindings, path) {
+    let nearest;
+    for (const prefix of Object.keys(bindings))
+        if ((path === prefix || path.startsWith(`${prefix}.`)) && (!nearest || prefix.length > nearest.length))
+            nearest = prefix;
+    return nearest;
+}
+/** Проверяет, что все сегменты пути объявлены и доступны для записи, включая родительские объекты.
+ * @example Для поля name без ограничений canWriteKey(entity, 'name') → true; для первичного ключа → false.
+ */
+export function canWriteKey(entity, path) {
+    const parts = pathParts(path);
+    return parts.every((_, index) => {
+        const field = entity.fields[parts.slice(0, index + 1).join('.')];
+        return field && !field.primary && !field.generated && !field.readOnly;
+    });
+}
+/** Распознаёт обратную связь: источник совпадает с первичным ключом, а целевой путь отличается от первичного ключа цели.
+ * @example При source = 'id', target = 'authorId' и первичных ключах id → true.
+ */
+export function isReverseRelation(entity, node) {
+    return node.source === entity.primary || (!canWriteKey(entity, node.source) && canWriteKey(node.relation, node.target));
+}
+/** Собирает значения по вложенному пути, проходя через массивы; отсутствующие значения и null пропускает.
+ * @example readPath({ rows: [{ id: 1 }, { id: 2 }] }, 'rows.id') → [1, 2].
+ */
 export const readPath = (value, path) => {
     const parts = typeof path === 'string' ? pathParts(path) : path;
     if (!parts.length)
@@ -43,8 +91,22 @@ export const readPath = (value, path) => {
         return value.flatMap((v) => readPath(v, parts));
     return isObject(value) && Object.hasOwn(value, parts[0]) ? readPath(value[parts[0]], parts.slice(1)) : [];
 };
+/** Возвращает последний сегмент пути поля.
+ * @example childName({ path: 'profile.name', … }) → 'name'.
+ */
 export const childName = (node) => node.path.split('.').at(-1);
+/** Для связи возвращает целевую сущность и её корень; обычный узел сохраняет без изменений.
+ * @example canonicalNode(author, { relation: book }) → [book, book.root].
+ * @example canonicalNode(author, author.root) → [author, author.root].
+ */
+export const canonicalNode = (entity, node) => (node.relation ? [node.relation, node.relation.root] : [entity, node]);
+/** Соединяет имя сущности и путь поля, заменяя точки подчёркиваниями.
+ * @example nodeName({ name: 'User', … }, { path: 'profile.name', … }) → 'User_profile_name'.
+ */
 export const nodeName = (entity, node) => (node.path ? `${entity.name}_${node.path.replaceAll('.', '_')}` : entity.name);
+/** Переводит первую букву имени сущности в нижний регистр.
+ * @example operationName({ name: 'UserProfile', … }) → 'userProfile'.
+ */
 export const operationName = (entity) => entity.name[0].toLowerCase() + entity.name.slice(1);
 const newNode = (path, field) => ({ ...field, path, base: field.type.replace(/\[\]$/, ''), many: field.type.endsWith('[]'), children: Object.create(null) });
 function addField(entity, path, field, implicit = false) {
@@ -63,11 +125,30 @@ function addField(entity, path, field, implicit = false) {
     const key = parts.at(-1);
     const node = newNode(path, field);
     node.implicit = implicit;
-    node.children = parent.children[key]?.children ?? {};
+    node.children = parent.children[key]?.children ?? Object.create(null);
     parent.children[key] = node;
     entity.fields[path] = node;
     return node;
 }
+function systemFields(entity, options) {
+    const names = [
+        ...(entity.timestamps ? ['createdAt', 'updatedAt'] : []),
+        DELETION_META,
+        ...(entity.softDelete ? ['deletedAt'] : []),
+        ...(options.auth ? ['createdById', 'updatedById', ...(entity.softDelete ? ['deletedById'] : [])] : []),
+    ];
+    entity.root.softDelete = entity.softDelete;
+    for (const name of names) {
+        if (entity.fields[name])
+            throw new Error(`Reserved system field ${entity.name}.${name}`);
+        const node = addField(entity, name, { type: 'string', readOnly: true, nullable: true, ...(name.endsWith('At') ? { format: 'date-time' } : {}) });
+        node.system = true;
+        if (name === DELETION_META) {
+            node.internal = true;
+            node.writeOnly = true;
+        }
+    }
+}
 function checkField(path, field) {
     if (!isObject(field))
         throw new Error(`Field ${path} must be an object`);
@@ -103,6 +184,8 @@ function checkField(path, field) {
     if (field.format !== undefined && !['date', 'date-time', 'email', 'uri', 'uuid'].includes(String(field.format)))
         throw new Error(`${path}: unknown format`);
     const base = field.type.replace(/\[\]$/, '');
+    if (base === 'object' && field.enum !== undefined)
+        throw new Error(`${path}: enum is supported only for primitive fields`);
     if (['minLength', 'maxLength', 'pattern', 'format'].some((k) => field[k] !== undefined) && base !== 'string')
         throw new Error(`${path}: string constraint on non-string field`);
     if (['minimum', 'maximum'].some((k) => field[k] !== undefined) && base !== 'number')
@@ -114,29 +197,44 @@ function checkField(path, field) {
     if (typeof field.minLength === 'number' && typeof field.maxLength === 'number' && field.minLength > field.maxLength)
         throw new Error(`${path}: minLength exceeds maxLength`);
 }
-export async function loadModel(source) {
+/** Загружает описание из объекта или JSON-файла, проверяет поля и сопоставляет связи.
+ * @example loadModel(undefined) → Promise<undefined>; корректное описание → Promise<Model>.
+ */
+export async function loadModel(source, settings = {}) {
     if (source === undefined)
         return undefined;
-    const schema = typeof source === 'string' ? JSON.parse(await readFile(source, 'utf8')) : source;
+    const schema = typeof source === 'string' ? JSON.parse(await readFile(source, 'utf8')) : structuredClone(source);
+    const ajv = createValidator();
     if (!isObject(schema) || !Object.keys(schema).length)
         throw new Error('Model schema must be a nonempty object');
-    if ('$schema' in schema || '$info' in schema)
-        throw new Error('Legacy $schema/$info format is no longer supported');
-    const model = { entities: [], byName: new Map(), byCollection: new Map(), explicit: true };
-    for (const [name, definition] of Object.entries(schema)) {
+    assertKnownKeys(schema, new Set(['models', 'api', 'timestamps', 'softDelete']), 'schema');
+    if (!isObject(schema.models) || !Object.keys(schema.models).length)
+        throw new Error('schema.models must be a nonempty object');
+    const options = recordOptions({ auth: settings.auth, timestamps: schema.timestamps, softDelete: schema.softDelete });
+    const defaults = apiFormats(schema.api, apiFormats(settings.api, ['openapi', 'graphql'], 'defaults'), 'schema');
+    const model = { entities: [], byName: new Map(), byCollection: new Map(), explicit: true, options };
+    for (const [name, definition] of Object.entries(schema.models)) {
         if (!NAME.test(name) || !isSafeKey(name) || PRIMITIVES.has(name) || !isObject(definition))
             throw new Error(`Invalid model ${name}`);
-        assertKnownKeys(definition, new Set(['collection', 'api', 'fields']), name);
+        assertKnownKeys(definition, new Set(['collection', 'api', 'fields', 'timestamps', 'softDelete']), name);
         if (typeof definition.collection !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(definition.collection) || !isSafeKey(definition.collection))
             throw new Error(`Invalid collection for ${name}`);
         if (model.byCollection.has(definition.collection))
             throw new Error(`Duplicate collection ${definition.collection}`);
-        const api = definition.api ?? ['openapi', 'graphql'];
-        if (!Array.isArray(api) || api.some((v) => !['openapi', 'graphql'].includes(v)) || new Set(api).size !== api.length)
-            throw new Error(`Invalid api for ${name}`);
+        const api = apiFormats(definition.api, defaults, name);
         if (!isObject(definition.fields))
             throw new Error(`${name}.fields must be an object`);
-        const entity = { name, collection: definition.collection, api, primary: '', fields: Object.create(null), root: newNode('', { type: 'object' }) };
+        const flags = recordOptions({ timestamps: definition.timestamps, softDelete: definition.softDelete });
+        const entity = {
+            timestamps: definition.timestamps === undefined ? options.timestamps : flags.timestamps,
+            softDelete: definition.softDelete === undefined ? options.softDelete : flags.softDelete,
+            name,
+            collection: definition.collection,
+            api,
+            primary: '',
+            fields: Object.create(null),
+            root: newNode('', { type: 'object' }),
+        };
         for (const [path, field] of Object.entries(definition.fields).sort(([a], [b]) => a.split('.').length - b.split('.').length)) {
             checkField(path, field);
             addField(entity, path, field);
@@ -149,6 +247,8 @@ export async function loadModel(source) {
         }
         if (!entity.primary)
             throw new Error(`${name}: primary key is required`);
+        systemFields(entity, options);
+        entityValidators.set(entity, ajv);
         model.entities.push(entity);
         model.byName.set(name, entity);
         model.byCollection.set(entity.collection, entity);
@@ -200,18 +300,47 @@ export async function loadModel(source) {
             if (node.relation) {
                 const sourceField = entity.fields[node.source];
                 const targetField = node.relation.fields[node.target];
+                if (!sourceField.primary)
+                    sourceField.relationKey = true;
+                if (!targetField.primary)
+                    targetField.relationKey = true;
                 if (sourceField.relation || targetField.relation || !['string', 'number'].includes(sourceField.base) || sourceField.base !== targetField.base)
                     throw new Error(`Incompatible relation keys: ${entity.name}.${node.path}`);
             }
             else {
-                const validate = ajv.compile(valueSchema(node));
+                const schema = valueSchema(node);
+                const validate = ajv.compile(schema);
                 for (const key of ['default', 'example'])
                     if (node[key] !== undefined && !validate(structuredClone(node[key])))
                         throw new Error(`Invalid ${key}: ${entity.name}.${node.path}`);
+                ajv.removeSchema(schema);
             }
         }
+    for (const entity of model.entities) {
+        const check = (node, inArray = false, protectedParent = false) => {
+            if (inArray && node.readOnly && !protectedParent)
+                throw new Error(`Read-only fields inside arrays require a readOnly parent: ${entity.name}.${node.path}`);
+            for (const child of Object.values(node.children))
+                check(child, inArray || node.many, protectedParent || !!node.readOnly);
+        };
+        check(entity.root);
+    }
     return model;
 }
+/** Определяет доступность поля для выбранного режима записи, учитывая защищённые дочерние поля.
+ * @example writable({ readOnly: true, … }, 'update') → false.
+ */
+export function writable(node, mode, relations = false) {
+    if (node.relation)
+        return relations;
+    if (node.generated || node.readOnly || (node.primary && mode !== 'create'))
+        return false;
+    const children = Object.values(node.children);
+    return node.base !== 'object' || children.length === 0 || children.some((child) => writable(child, mode, relations));
+}
+/** Проверяет наличие явной модели и доступность выбранного формата для её связей.
+ * @example assertApi(undefined, 'graphql') → ошибка; согласованная модель → undefined.
+ */
 export function assertApi(model, api) {
     if (!model?.explicit)
         throw new Error(`${api} requires an explicit model schema`);
@@ -220,6 +349,9 @@ export function assertApi(model, api) {
             if (node.relation && !node.relation.api.includes(api))
                 throw new Error(`${entity.name}.${node.path}: ${node.relation.name} does not enable ${api}`);
 }
+/** Строит схему проверки значения с ограничениями, массивом и допустимостью null.
+ * @example Для строкового узла без ограничений valueSchema(node) → { type: 'string' }.
+ */
 export function valueSchema(node) {
     let schema = node.base === 'object' ? objectSchema(node, 'stored') : { type: node.base };
     for (const key of ['minLength', 'maxLength', 'pattern', 'format', 'minimum', 'maximum', 'enum'])
@@ -231,53 +363,110 @@ export function valueSchema(node) {
         schema = { anyOf: [schema, { type: 'null' }] };
     return schema;
 }
-export function objectSchema(node, mode, root = false) {
+/** Строит схему объекта для выбранного режима; при частичном обновлении корневые поля необязательны.
+ * @example Для пустого узла → { type: 'object', properties: {}, additionalProperties: false }.
+ */
+export function objectSchema(node, mode, root = false, relationSchema) {
     const properties = {};
     const required = [];
     for (const [key, child] of Object.entries(node.children)) {
-        if (child.relation || (mode !== 'stored' && (child.generated || child.readOnly || (child.primary && mode !== 'create'))))
+        if (child.relation) {
+            if (mode !== 'stored' && relationSchema)
+                properties[key] = relationSchema(child);
+            continue;
+        }
+        if (mode !== 'stored' && !writable(child, mode, !!relationSchema))
             continue;
         properties[key] =
             child.base === 'object'
                 ? (() => {
-                    let s = objectSchema(child, mode);
+                    let s = objectSchema(child, mode, false, relationSchema);
                     if (child.many)
                         s = { type: 'array', items: s };
                     return child.nullable ? { anyOf: [s, { type: 'null' }] } : s;
                 })()
                 : valueSchema(child);
-        if (child.required && !(root && mode === 'update') && !(mode !== 'stored' && child.default !== undefined))
+        if (child.required && !(root && mode === 'update') && !(mode !== 'stored' && child.default !== undefined) && !(relationSchema && child.relationKey))
             required.push(key);
     }
+    // Сохраняем ранее записанные даты и авторов при отключении соответствующих флагов.
+    if (root && mode === 'stored')
+        for (const name of AUDIT_FIELDS)
+            properties[name] ??= { type: ['string', 'null'], ...(name.endsWith('At') ? { format: 'date-time' } : {}) };
     return { type: 'object', properties, additionalProperties: false, ...(required.length ? { required } : {}) };
 }
-export const validators = new WeakMap();
-export function validateRecord(entity, value, mode) {
+export function relationInputSchema(node, object = { type: 'object' }) {
+    const target = node.relation;
+    let schema = { anyOf: [valueSchema(target.fields[target.primary]), object] };
+    if (node.many)
+        schema = { type: 'array', items: schema };
+    else if (node.nullable)
+        schema = { anyOf: [schema, { type: 'null' }] };
+    return schema;
+}
+const validators = new WeakMap();
+/** Проверяет запись по схеме выбранного режима и выбрасывает исключение при несоответствии.
+ * @example Обязательное строковое name: { name: 'Анна' } → undefined; { name: 2 } → ошибка.
+ */
+export function validateRecord(entity, value, mode, relations = false) {
+    const ajv = entityValidators.get(entity);
     let cache = validators.get(entity);
     if (!cache) {
         cache = new Map();
         validators.set(entity, cache);
     }
-    let validate = cache.get(mode);
+    const key = `${mode}:${relations}`;
+    let validate = cache.get(key);
     if (!validate) {
-        validate = ajv.compile(objectSchema(entity.root, mode, true));
-        cache.set(mode, validate);
+        validate = ajv.compile(objectSchema(entity.root, mode, true, relations ? (node) => relationInputSchema(node) : undefined));
+        cache.set(key, validate);
     }
     if (!validate(value))
-        throw createHttpError(400, `${entity.name}: ${ajv.errorsText(validate.errors)}`);
+        throw domainError('INVALID_INPUT', `${entity.name}: ${ajv.errorsText(validate.errors)}`);
 }
-export function inferModel(database) {
-    const model = { entities: [], byName: new Map(), byCollection: new Map(), explicit: false };
+/** Выводит поля и связи из значений коллекций, не меняя переданные записи.
+ * @example inferModel({ users: [{ id: '1', name: 'Анна' }] }) → модель со строковыми id и name.
+ */
+export function inferModel(database, settings = {}) {
+    const options = recordOptions(settings);
+    const valueType = (value) => (isObject(value) ? 'object' : ['string', 'number', 'boolean'].includes(typeof value) ? typeof value : 'string');
+    const model = { entities: [], byName: new Map(), byCollection: new Map(), explicit: false, options };
     for (const [collection, records] of Object.entries(database)) {
         const name = toPascalCase(singularize(collection));
-        const entity = { name, collection, api: [], primary: 'id', fields: Object.create(null), root: newNode('', { type: 'object' }) };
+        const entity = {
+            timestamps: options.timestamps,
+            softDelete: options.softDelete,
+            name,
+            collection,
+            api: [],
+            primary: 'id',
+            fields: Object.create(null),
+            root: newNode('', { type: 'object' }),
+        };
+        systemFields(entity, options);
+        const observed = new Map();
         const scan = (record, prefix = '') => {
             for (const [key, value] of Object.entries(record)) {
+                if (!NAME.test(key) || !isSafeKey(key) || (!prefix && entity.fields[key]?.system))
+                    continue;
                 const path = prefix + key;
                 const sample = Array.isArray(value) ? value.find((v) => v !== null) : value;
-                const base = isObject(sample) ? 'object' : ['string', 'number', 'boolean'].includes(typeof sample) ? typeof sample : 'string';
-                if (!entity.fields[path] || sample != null)
-                    addField(entity, path, { type: base + (Array.isArray(value) ? '[]' : '') });
+                const base = valueType(sample);
+                const type = base + (Array.isArray(value) ? '[]' : '');
+                const types = observed.get(path) ?? new Set();
+                for (const element of Array.isArray(value) ? value : [value]) {
+                    if (element == null)
+                        continue;
+                    types.add(valueType(element) + (Array.isArray(value) ? '[]' : ''));
+                }
+                observed.set(path, types);
+                const node = entity.fields[path] ?? addField(entity, path, { type });
+                if (types.size) {
+                    node.mixed = node.mixed || types.size > 1 || (Array.isArray(value) && value.some(isObject) && value.some((item) => !isObject(item)));
+                    node.base = [...types].some((type) => type.startsWith('object')) ? 'object' : [...types].sort()[0].replace(/\[\]$/, '');
+                    node.many = [...types].every((type) => type.endsWith('[]'));
+                    node.type = node.base + (node.many ? '[]' : '');
+                }
                 if (isObject(value))
                     scan(value, `${path}.`);
                 if (Array.isArray(value))
@@ -299,6 +488,8 @@ export function inferModel(database) {
     const resources = Object.keys(database);
     for (const entity of model.entities)
         for (const field of Object.values(entity.fields)) {
+            if (field.mixed || field.system)
+                continue;
             const relation = getRelationMetadata(childName(field), resources, entity.collection);
             if (!relation)
                 continue;