@kollors/deep-json-server 1.0.0-alpha.3 → 1.0.0-alpha.5

package/README.md

@@ -4,7 +4,7 @@
 
 A JSON-backed mock server with REST, GraphQL, nested queries, binary files and schema exports. Requires Node.js 22 or newer.
 
-**1.0.0-alpha.3 is a prerelease.** When upgrading from 0.x, update your model schema and query parameters using the examples below.
+**1.0.0-alpha.5 is a prerelease.** REST queries use `scope=[fields, arguments?]` at every level. When upgrading from an earlier version, update query parameters using the examples below; upgrading from 0.x also requires the new model schema.
 
 ## Installation
 
@@ -12,7 +12,7 @@ A JSON-backed mock server with REST, GraphQL, nested queries, binary files and s
 npm install @kollors/deep-json-server@alpha
 ```
 
-To install a specific version, use `@1.0.0-alpha.3`.
+To install a specific version, use `@1.0.0-alpha.5`.
 
 ## Quick start
 
@@ -136,7 +136,7 @@ Examples: [database](examples/database.json), [model schema](examples/schema.jso
 
 Explicit schemas are strict: undeclared fields and collections are rejected, except storage keys inferred from relations. Existing data is validated on startup. Generation uses the model definitions.
 
-Schemaless REST generates an `id` and preserves arbitrary JSON fields. Filters and individual field selections use identifier-style names; other fields are returned through `scope=*`. Fields with mixed value types can be read, but using them in `where`, `order` or `nested` requires an explicit schema.
+Schemaless REST generates an `id` and preserves arbitrary JSON fields. Filters and individual field selections use identifier-style names; other fields are returned through `scope=[{"*":true}]`. Fields with mixed value types can be read, but filtering, ordering and paging heterogeneous lists require an explicit schema.
 
 ### Fields
 
@@ -235,37 +235,112 @@ Root `where` selects records from the main collection. `where` inside a relation
 
 The path parameter name follows the primary key. POST, PUT and PATCH accept a JSON record object. PUT replaces the record while retaining its key and server-managed fields. PATCH merges fields at the top level; supplied nested objects are replaced while preserving their read-only fields. Creation and replacement require all mandatory fields. Updates validate supplied values and the final record. Missing records return `404`; conflicts return `409`. DELETE returns the deleted record.
 
-Query parameters `where`, `order`, `pager`, `nested` contain JSON. `scope` is a selection string. Example shown before URL encoding:
+### Nested writes
 
-```text
-GET /users?where={"fullName":{"contains":"Мира"}}&order=[{"field":"fullName","direction":"ASC"}]&pager={"page":1,"pageSize":20}
+Storage keys such as `genreIds: ["1"]` only set a relation. Relation fields also accept records to create or update:
+
+```http
+PATCH /movies/1
+Content-Type: application/json
+
+{
+  "actors": [
+    {
+      "userId": "1",
+      "genres": [
+        "1",
+        { "id": "2", "name": "Updated genre" },
+        { "name": "New genre" }
+      ]
+    }
+  ]
+}
 ```
 
-Construct encoded URLs with `URLSearchParams`:
+| Relation value | Behavior |
+|---|---|
+| A key, such as `"1"` | Link an existing record without changing it |
+| An object with a primary key | PATCH updates supplied fields; PUT replaces the related record |
+| An object without a primary key | Create a related record with defaults and a generated key |
+
+The key name and type follow the target model. An object containing only a key still counts as an update: in PUT it must include the model's required fields. Replacement preserves primary keys, generated values and `readOnly` fields. In POST, nested objects with existing keys receive partial updates. A missing target is an error; creating a nested record without a key requires an autogenerated primary key.
+
+A supplied list replaces the relation's membership. PATCH preserves omitted relations; PUT clears omitted writable links. `[]` clears a list and `null` clears a nullable single relation. Removing a link does not delete the related record. Required relations must remain populated.
+
+Use either the relation field or its storage key in an object, for example `genres` or `genreIds`. Reverse relations update the target key. If a target path crosses an array and the server cannot identify one element to attach, provide the array with the intended keys explicitly. Protected keys cannot be changed.
+
+All nested changes belong to the main record's transaction. A validation error, missing record or invalid response selection rolls back the entire operation. Updating a shared record affects every record linked to it.
+
+GraphQL accepts typed objects in relation fields. To change only the links in a replace mutation, use storage keys such as `genreIds`. For example:
+
+```graphql
+mutation {
+  movieUpdate(id: "1", data: {
+    actors: [{
+      userId: "1"
+      genres: [{ id: "2", name: "Updated genre" }, { name: "New genre" }]
+    }]
+  }) {
+    actors { data { genres { data { id name } } } }
+  }
+}
+```
+
+### REST query parameters
+
+REST accepts one query parameter, `scope`, containing a JSON array `[fields, arguments?]`. The first object selects fields; the optional second object supplies `where`, `order` and `pager` for a list. The same format applies to the root query, embedded objects and relations.
+
+Select users and their movies with independent ordering and pagination:
 
 ```js
-const params = new URLSearchParams({
-  scope: 'id,fullName,movies(id,title)',
-  nested: JSON.stringify({ movies: { order: [{ field: 'title', direction: 'ASC' }], pager: { page: 1, pageSize: 5 } } }),
-});
+const scope = [
+  {
+    id: true,
+    fullName: true,
+    movies: [
+      { id: true, title: true },
+      {
+        order: [{ field: 'title', direction: 'ASC' }],
+        pager: { page: 1, pageSize: 5 },
+      },
+    ],
+  },
+  {
+    where: { fullName: { contains: 'Мира' } },
+    order: [{ field: 'fullName', direction: 'ASC' }],
+    pager: { page: 1, pageSize: 20 },
+  },
+];
+const params = new URLSearchParams({ scope: JSON.stringify(scope) });
 const response = await fetch(`/users?${params}`);
 ```
 
-`scope=*,actors(user(id,fullName),genres(*))` selects own fields and the specified relations. `*` includes the current object's own fields and stored keys, except `writeOnly` fields. Relations are listed explicitly. The default selection is own fields. Lists retain the `{ data, total }` response structure.
+Select ordinary fields with `true` and objects or relations with their own scope arrays. Without arguments, the array contains only the fields object. `"*": true` includes own fields and stored keys, except `writeOnly` fields; select relations explicitly.
 
-`nested` maps full response paths to list options:
+For example, select a movie's own fields, its actors' users and sorted genres:
 
 ```json
-{
-  "actors": { "pager": { "pageSize": 5 } },
-  "actors.genres": {
-    "where": { "id": { "in": ["2", "3"] } },
-    "order": [{ "field": "name", "direction": "ASC" }]
+[
+  {
+    "*": true,
+    "actors": [
+      {
+        "user": [{ "id": true, "fullName": true }],
+        "genres": [
+          { "*": true },
+          { "order": [{ "field": "name", "direction": "ASC" }] }
+        ]
+      }
+    ]
   }
-}
+]
 ```
 
-A path in `nested` must be selected by `scope` and point to an object list. Single-record routes and mutations accept `scope` and `nested`; root `where`, `order` and `pager` apply to collection GET. Invalid names and unsafe paths return `400`.
+Omitting `scope` returns own fields, as with `[{"*":true}]`. An empty selection `[{}]` returns an object without fields. Lists retain the `{ data, total }` response structure.
+
+Arguments are available only on lists. Single-record queries and mutation responses can set arguments on their embedded lists. Parameters are validated even on empty data; an invalid response selection rolls back record changes. Invalid scopes return `400`. The JSON length limit is 10,000 characters; selection depth is limited to 32 levels.
+
+OpenAPI remains at version 3.0.3. It cannot define a separate schema for each array position: the documentation describes the elements, and the server strictly validates their order.
 
 ### GraphQL
 

package/README.ru.md

@@ -4,7 +4,7 @@
 
 JSON-сервер для имитации API: REST, GraphQL, вложенные запросы, бинарные файлы и экспорт схем. Требуется Node.js 22 или новее.
 
-**1.0.0-alpha.3 — предварительная версия.** При переходе с 0.x обновите схему моделей и параметры запросов по примерам ниже.
+**1.0.0-alpha.5 — предварительная версия.** REST-запросы используют `scope=[поля, аргументы?]` на всех уровнях. При обновлении измените параметры запросов по примерам ниже; для перехода с 0.x также нужна новая схема моделей.
 
 ## Установка
 
@@ -12,7 +12,7 @@ JSON-сервер для имитации API: REST, GraphQL, вложенные
 npm install @kollors/deep-json-server@alpha
 ```
 
-Для установки конкретной версии укажите `@1.0.0-alpha.3`.
+Для установки конкретной версии укажите `@1.0.0-alpha.5`.
 
 ## Быстрый старт
 
@@ -136,7 +136,7 @@ export default {
 
 При явной схеме неизвестные поля и коллекции запрещены. Исключение — хранимые ключи, выведенные из связей. Исходная база проверяется при загрузке. Генерация использует описание моделей.
 
-REST без схемы создаёт ключ `id` и сохраняет произвольные JSON-поля. Для фильтров и выбора отдельных полей используются имена в формате идентификаторов; остальные поля возвращаются через `scope=*`. Поля с разными типами значений можно читать, но для их использования в `where`, `order` или `nested` нужна явная схема.
+REST без схемы создаёт ключ `id` и сохраняет произвольные JSON-поля. Для фильтров и выбора отдельных полей используются имена в формате идентификаторов; остальные поля возвращаются через `scope=[{"*":true}]`. Поля с разными типами значений можно читать, но фильтрация, сортировка и пагинация неоднородных списков требуют явной схемы.
 
 ### Поля
 
@@ -235,37 +235,112 @@ REST без схемы создаёт ключ `id` и сохраняет про
 
 Имя параметра пути соответствует первичному ключу. POST, PUT и PATCH принимают JSON-объект записи. PUT заменяет запись с сохранением ключа и серверных полей. PATCH объединяет поля на верхнем уровне; переданные вложенные объекты заменяются с сохранением их полей `readOnly`. Создание и замена требуют всех обязательных полей. При обновлении проверяются переданные значения и итоговая запись. Отсутствующая запись — `404`, конфликт — `409`. DELETE возвращает удалённую запись.
 
-Параметры `where`, `order`, `pager`, `nested` содержат JSON; `scope` — строку выбора. Пример до URL-кодирования:
+### Вложенная запись
 
-```text
-GET /users?where={"fullName":{"contains":"Мира"}}&order=[{"field":"fullName","direction":"ASC"}]&pager={"page":1,"pageSize":20}
+Поля ключей, например `genreIds: ["1"]`, только задают связь. В поля связей можно передавать записи для создания или обновления:
+
+```http
+PATCH /movies/1
+Content-Type: application/json
+
+{
+  "actors": [
+    {
+      "userId": "1",
+      "genres": [
+        "1",
+        { "id": "2", "name": "Обновлённый жанр" },
+        { "name": "Новый жанр" }
+      ]
+    }
+  ]
+}
 ```
 
-Кодирование через `URLSearchParams`:
+| Значение в связи | Действие |
+|---|---|
+| Ключ, например `"1"` | Связать существующую запись без её изменения |
+| Объект с первичным ключом | PATCH обновляет переданные поля, PUT заменяет связанную запись |
+| Объект без первичного ключа | Создать запись со значениями по умолчанию и сгенерированным ключом |
+
+Имя и тип ключа берутся из целевой модели. Объект только с ключом тоже считается обновлением: в PUT он должен содержать обязательные поля модели. При замене сохраняются первичный ключ, генерируемые значения и поля `readOnly`. В POST вложенные объекты с существующими ключами обновляются частично. Если запись по ключу не найдена, операция завершится ошибкой. Для создания вложенной записи без ключа нужна его автоматическая генерация.
+
+Переданный список заменяет состав связи. PATCH сохраняет пропущенные связи, PUT очищает пропущенные связи, ключи которых доступны для записи. `[]` очищает список, `null` — одиночную связь с разрешённым `nullable`. Разрыв связи не удаляет связанную запись. Обязательные связи должны оставаться заполненными.
+
+В одном объекте указывайте либо связь, либо её хранимый ключ: например, `genres` или `genreIds`. Для обратной связи сервер меняет целевой ключ. Если путь проходит через массив и нельзя однозначно выбрать элемент для связи, передайте массив с нужными ключами явно. Защищённые ключи изменять нельзя.
+
+Все вложенные изменения входят в транзакцию основной записи. Ошибка проверки, отсутствующая запись или неверный выбор полей ответа отменяет всю операцию. Изменения общей записи видны всем, кто с ней связан.
+
+GraphQL принимает в полях связей типизированные объекты. Чтобы при замене изменить только связи, используйте поля ключей, например `genreIds`. Пример:
+
+```graphql
+mutation {
+  movieUpdate(id: "1", data: {
+    actors: [{
+      userId: "1"
+      genres: [{ id: "2", name: "Обновлённый жанр" }, { name: "Новый жанр" }]
+    }]
+  }) {
+    actors { data { genres { data { id name } } } }
+  }
+}
+```
+
+### Параметры REST-запросов
+
+REST принимает один query-параметр `scope` с JSON-массивом `[поля, аргументы?]`. Первый объект выбирает поля, второй задаёт `where`, `order` и `pager` для списка. Этот формат одинаков для корневого запроса, вложенных объектов и связей.
+
+Пример выбора пользователей и их фильмов с отдельной сортировкой и пагинацией:
 
 ```js
-const params = new URLSearchParams({
-  scope: 'id,fullName,movies(id,title)',
-  nested: JSON.stringify({ movies: { order: [{ field: 'title', direction: 'ASC' }], pager: { page: 1, pageSize: 5 } } }),
-});
+const scope = [
+  {
+    id: true,
+    fullName: true,
+    movies: [
+      { id: true, title: true },
+      {
+        order: [{ field: 'title', direction: 'ASC' }],
+        pager: { page: 1, pageSize: 5 },
+      },
+    ],
+  },
+  {
+    where: { fullName: { contains: 'Мира' } },
+    order: [{ field: 'fullName', direction: 'ASC' }],
+    pager: { page: 1, pageSize: 20 },
+  },
+];
+const params = new URLSearchParams({ scope: JSON.stringify(scope) });
 const response = await fetch(`/users?${params}`);
 ```
 
-`scope=*,actors(user(id,fullName),genres(*))` выбирает собственные поля и указанные связи. `*` включает собственные поля текущего объекта и хранимые ключи, кроме полей `writeOnly`. Связи перечисляются явно. По умолчанию выбираются собственные поля. Списки сохраняют структуру ответа `{ data, total }`.
+Обычные поля выбираются через `true`, объекты и связи — через свой массив `scope`. Если аргументы не нужны, в массиве остаётся только объект полей. `"*": true` включает собственные поля и хранимые ключи, кроме `writeOnly`; связи выбираются явно.
 
-`nested` сопоставляет полные пути ответа и настройки списков:
+Например, собственные поля фильма, пользователи актёров и отсортированные жанры:
 
 ```json
-{
-  "actors": { "pager": { "pageSize": 5 } },
-  "actors.genres": {
-    "where": { "id": { "in": ["2", "3"] } },
-    "order": [{ "field": "name", "direction": "ASC" }]
+[
+  {
+    "*": true,
+    "actors": [
+      {
+        "user": [{ "id": true, "fullName": true }],
+        "genres": [
+          { "*": true },
+          { "order": [{ "field": "name", "direction": "ASC" }] }
+        ]
+      }
+    ]
   }
-}
+]
 ```
 
-Путь в `nested` должен быть выбран через `scope` и вести к списку объектов. Маршруты отдельных записей и мутации принимают `scope` и `nested`; корневые `where`, `order` и `pager` применяются к GET коллекции. Неизвестные имена и небезопасные пути возвращают `400`.
+Без `scope` возвращаются собственные поля, как при `[{"*":true}]`. Пустой выбор `[{}]` возвращает объект без полей. Списки сохраняют структуру `{ data, total }`.
+
+Аргументы доступны только у списков. В запросе отдельной записи и в ответе мутации их можно задать для вложенных списков. Параметры проверяются даже на пустых данных; ошибка в выборе ответа отменяет изменения записи. Некорректный `scope` возвращает `400`. Максимальная длина JSON — 10 000 символов, глубина выбора — 32 уровня.
+
+OpenAPI остаётся версии 3.0.3. В этой версии нельзя задать отдельную схему для каждой позиции массива: назначение элементов описано в документации, а их порядок строго проверяет сервер.
 
 ### GraphQL
 

package/dist/src/constants.d.ts

@@ -3,4 +3,4 @@ export declare const DEFAULT_MAX_FILE_SIZE: number;
 export declare const DEFAULT_MAX_PAGE_SIZE = 100;
 export declare const DEFAULT_PAGE_SIZE = 10;
 export declare const DEFAULT_PORT = 4001;
-export declare const VERSION = "1.0.0-alpha.3";
+export declare const VERSION = "1.0.0-alpha.5";

package/dist/src/constants.js

@@ -3,5 +3,5 @@ export const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024;
 export const DEFAULT_MAX_PAGE_SIZE = 100;
 export const DEFAULT_PAGE_SIZE = 10;
 export const DEFAULT_PORT = 4001;
-export const VERSION = '1.0.0-alpha.3';
+export const VERSION = '1.0.0-alpha.5';
 //# sourceMappingURL=constants.js.map

package/dist/src/engine.d.ts

@@ -2,22 +2,8 @@ import type { DatabaseStore } from './database.js';
 import { type Entity, type Model, type Node } from './model.js';
 import { type Predicate } from './query/filter.js';
 import { type ListOptions } from './query/options.js';
-import type { DatabaseData, JsonObject } from './types.js';
-declare const REF: unique symbol;
-export interface Ref {
-    [REF]: true;
-    entity: Entity;
-    node: Node;
-    value: JsonObject;
-    root: JsonObject;
-    bindings: Record<string, JsonObject>;
-    context: Context;
-}
-export interface Context {
-    data: DatabaseData;
-    model: Model;
-    indexes: Map<string, Map<string, JsonObject[]>>;
-}
+import { type Context, type Ref } from './records.js';
+import type { DatabaseData } from './types.js';
 export interface PreparedList {
     page: number;
     pageSize: number;
@@ -31,11 +17,6 @@ export interface Page {
     data: Ref[];
     total: number;
 }
-export declare const makeContext: (data: DatabaseData, model: Model) => Context;
-export declare const rootRef: (context: Context, entity: Entity, value: JsonObject) => Ref;
-export declare function related(ref: Ref, node: Node): Ref[];
-export declare function resolveField(ref: Ref, node: Node): unknown;
-export declare const isRef: (value: unknown) => value is Ref;
 export declare class Engine {
     readonly store: DatabaseStore;
     model: Model;
@@ -50,9 +31,6 @@ export declare class Engine {
     prepareOptions(node: Node, options?: ListOptions): PreparedList;
     list(records: Ref[], node: Node, options?: ListOptions, prepared?: PreparedList): Page;
     validateData(data: DatabaseData): void;
-    private defaults;
-    private preserve;
     mutate<T = Ref>(entity: Entity, mode: 'create' | 'replace' | 'update' | 'delete', key?: unknown, body?: unknown, prepare?: (ref: Ref) => T): Promise<T>;
     private cascade;
 }
-export {};

package/dist/src/engine.js

@@ -1,58 +1,11 @@
-import { randomUUID } from 'node:crypto';
 import { DEFAULT_MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE } from './constants.js';
-import { createId } from './database.js';
 import { domainError } from './errors.js';
-import { childName, inferModel, pathParts, readPath, validateRecord } from './model.js';
+import { inferModel, isReverseRelation, pathParts, readPath, validateRecord } from './model.js';
+import { MutationWriter } from './mutations/write.js';
 import { compileWhere } from './query/filter.js';
 import { badQuery, childrenOf, nodeAt } from './query/options.js';
+import { isRef, keyOf, makeContext, related, resolveField, rootRef, sourceValues } from './records.js';
 import { isObject } from './utils.js';
-const REF = Symbol('record reference');
-export const makeContext = (data, model) => ({ data, model, indexes: new Map() });
-export const rootRef = (context, entity, value) => ({ [REF]: true, context, entity, node: entity.root, value, root: value, bindings: {} });
-const keyOf = (value) => `${typeof value}:${String(value)}`;
-function sourceValues(ref, node) {
-    const path = node.source;
-    const binding = Object.keys(ref.bindings)
-        .filter((prefix) => path === prefix || path.startsWith(`${prefix}.`))
-        .sort((a, b) => b.length - a.length)[0];
-    return binding ? readPath(ref.bindings[binding], path === binding ? [] : path.slice(binding.length + 1)) : readPath(ref.root, path);
-}
-export function related(ref, node) {
-    const entity = node.relation;
-    const indexKey = `${entity.collection}:${node.target}`;
-    let index = ref.context.indexes.get(indexKey);
-    if (!index) {
-        index = new Map();
-        for (const record of ref.context.data[entity.collection] ?? [])
-            for (const value of readPath(record, node.target)) {
-                const key = keyOf(value);
-                const bucket = index.get(key) ?? [];
-                bucket.push(record);
-                index.set(key, bucket);
-            }
-        ref.context.indexes.set(indexKey, index);
-    }
-    const found = new Set();
-    for (const value of sourceValues(ref, node))
-        for (const record of index.get(keyOf(value)) ?? [])
-            found.add(record);
-    return [...found].map((record) => rootRef(ref.context, entity, record));
-}
-export function resolveField(ref, node) {
-    if (node.relation) {
-        const records = related(ref, node);
-        return node.many ? records : (records[0] ?? null);
-    }
-    const key = childName(node);
-    const value = Object.hasOwn(ref.value, key) ? ref.value[key] : undefined;
-    if ((ref.context.model.explicit && node.base !== 'object') || value == null)
-        return value;
-    const wrap = (object) => ({ ...ref, node, value: object, bindings: { ...ref.bindings, [node.path]: object } });
-    if (Array.isArray(value))
-        return value.every(isObject) ? value.map(wrap) : value;
-    return isObject(value) ? wrap(value) : value;
-}
-export const isRef = (value) => isObject(value) && value[REF] === true;
 function filterView(ref) {
     const value = {};
     for (const [name, node] of Object.entries(childrenOf(ref.node)))
@@ -169,7 +122,7 @@ export class Engine {
                     if (node.required && !matches.length)
                         throw domainError('INVALID_INPUT', `Required relation ${ref.entity.name}.${node.path} is empty`);
                     const values = sourceValues(ref, node);
-                    if (node.source !== ref.entity.primary && values.some((value) => !matches.some((match) => readPath(match.value, node.target).some((target) => keyOf(target) === keyOf(value)))))
+                    if (!isReverseRelation(ref.entity, node) && values.some((value) => !matches.some((match) => readPath(match.value, node.target).some((target) => keyOf(target) === keyOf(value)))))
                         throw domainError('INVALID_INPUT', `Dangling relation ${ref.entity.name}.${node.path}`);
                 }
                 else if (node.base === 'object') {
@@ -189,46 +142,11 @@ export class Engine {
                 visit(rootRef(context, entity, record));
             }
     }
-    defaults(node, record) {
-        for (const [key, child] of Object.entries(node.children)) {
-            if (child.relation)
-                continue;
-            if (!Object.hasOwn(record, key) && child.default !== undefined)
-                record[key] = structuredClone(child.default);
-            if (child.base === 'object' && record[key] != null) {
-                const values = child.many ? record[key] : [record[key]];
-                values.forEach((value) => {
-                    this.defaults(child, value);
-                });
-            }
-        }
-    }
-    preserve(node, record, previous) {
-        for (const [key, child] of Object.entries(node.children)) {
-            if (child.relation)
-                continue;
-            if ((child.generated || child.readOnly) && previous && Object.hasOwn(previous, key))
-                record[key] = structuredClone(previous[key]);
-            else if (child.base === 'object' && !child.many) {
-                const old = previous?.[key];
-                if (isObject(record[key]))
-                    this.preserve(child, record[key], isObject(old) ? old : undefined);
-                else if (record[key] === undefined && isObject(old)) {
-                    const preserved = {};
-                    this.preserve(child, preserved, old);
-                    if (Object.keys(preserved).length)
-                        record[key] = preserved;
-                }
-            }
-        }
-    }
     async mutate(entity, mode, key, body, prepare) {
         if (mode !== 'delete') {
             if (!isObject(body))
                 throw domainError('INVALID_INPUT', 'Request body must be an object');
-            if (this.model.explicit)
-                validateRecord(entity, body, mode);
-            else if (Object.hasOwn(body, 'id'))
+            if (!this.model.explicit && Object.hasOwn(body, 'id'))
                 throw domainError('INVALID_INPUT', 'id is generated and immutable');
         }
         const outcome = await this.store.update((database) => {
@@ -251,51 +169,19 @@ export class Engine {
                             throw domainError('CONFLICT', 'Invalid increment counter');
                         counters[name] = maximum;
                     }
-            const context = makeContext(database.data, this.model);
-            const current = mode === 'create' ? undefined : this.find(context, entity, key);
-            if (mode !== 'create' && !current)
-                throw domainError('NOT_FOUND', 'Record not found');
-            database.data[entity.collection] ??= [];
-            const collection = database.data[entity.collection];
             if (mode === 'delete') {
+                const context = makeContext(database.data, this.model);
+                const current = this.find(context, entity, key);
+                if (!current)
+                    throw domainError('NOT_FOUND', 'Record not found');
                 const snapshot = structuredClone(database.data);
                 this.cascade(context, current);
                 this.validateData(database.data);
                 return finish(snapshot, current.value);
             }
-            const record = (mode === 'update' ? { ...current?.value, ...structuredClone(body) } : structuredClone(body));
-            if (mode !== 'create') {
-                record[entity.primary] = current.value[entity.primary];
-                this.preserve(entity.root, record, current?.value);
-            }
-            if (this.model.explicit) {
-                if (mode !== 'update')
-                    this.defaults(entity.root, record);
-                if (mode === 'create')
-                    for (const [name, field] of Object.entries(entity.root.children)) {
-                        if (field.generated === 'uuid')
-                            record[name] = randomUUID();
-                        if (field.generated === 'increment') {
-                            database.counters ??= {};
-                            const counters = database.counters;
-                            const counterKey = `${entity.collection}.${name}`;
-                            const largest = counters[counterKey] ?? 0;
-                            if (!Number.isSafeInteger(largest) || largest >= Number.MAX_SAFE_INTEGER)
-                                throw domainError('CONFLICT', 'Increment key exhausted');
-                            record[name] = largest + 1;
-                            counters[counterKey] = largest + 1;
-                        }
-                    }
-            }
-            else if (mode === 'create')
-                record.id = createId(collection);
-            const collision = collection.some((v) => v !== current?.value && String(v[entity.primary]) === String(record[entity.primary]));
-            if (collision)
-                throw domainError('CONFLICT', 'Primary key already exists');
-            if (mode === 'create')
-                collection.push(record);
-            else
-                collection[collection.indexOf(current.value)] = record;
+            const writer = new MutationWriter(database, this.model, mode === 'replace' ? 'replace' : 'update');
+            const record = writer.write(entity, mode, key, body);
+            writer.validateRelations();
             this.validateData(database.data);
             return finish(database.data, record);
         });