letopis 1.4.1 → 2.0.0

package/dist/write.js

@@ -1,7 +1,7 @@
 /**
- * Запись планами (план, §2.5, этап 4, п. 1–7, 10): глаголы create, update, upsert, delete, anonymize
- * и reclass — звенья цепочки; терминал исполняет весь план одной транзакцией. Этап 6: restore и
- * purge — над удалёнными объектами шага, rekey — новое значение ключа (функции базы).
+ * Запись планами (план, §2.5, этап 4, п. 1–7, 10): глаголы create, update, upsert и delete — звенья
+ * цепочки; терминал исполняет весь план одной транзакцией. Этап 6: restore — над удалёнными объектами
+ * шага (функция базы).
  *
  *   await db.Org(org).Staff().create({ name: 'Вася', phone: '+7' }).rows()      // концы из пути: { Org }
  *   await db.Customer(c).booking({ notes: 'x' }).update({ notes: 'y' }).rows()
@@ -17,10 +17,9 @@
  * строка видна, но править нельзя — acl_denied; строки уже нет — target_not_found; номер версии
  * разошёлся со { rev } — conflict.
  */
-import { LetopisError, ValidationError } from './errors.js';
+import { lerr, ValidationError } from './errors.js';
 import { isOp } from './ops.js';
-import { aggregateFields } from './registry.js';
-import { accepts, buildRead, nextNodeKey, resolveHop, stepClasses, toRow } from './sql.js';
+import { accepts, buildRead, nextNodeKey, precheckStep, resolveHop, stepClasses, toRow } from './sql.js';
 import { idOf } from './uuid.js';
 import { applyDefaults } from './validate.js';
 // ---------------------------------------------------------------------------
@@ -40,13 +39,10 @@ export const isInc = (v) => typeof v === 'object' && v !== null && v[INC] === tr
 /** Причина изменения: строка до 1000 символов без NUL (её не принимает set_config). */
 export function checkReason(v, where) {
     if (typeof v !== 'string' || v.length > 1000 || v.includes('\0')) {
-        throw new LetopisError('invalid_query', `${where}: reason — строка до 1000 символов`);
+        throw lerr('write.bad_reason', { where });
     }
     return v;
 }
-const fail = (code, msg, detail) => {
-    throw new LetopisError(code, msg, detail);
-};
 const asList = (v) => (Array.isArray(v) ? v : [v]);
 const isPlain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Date) && !isInc(v) && !isOp(v);
 /** Патч update → остаток для merge и список приращений. Недопустимое — invalid_data до отправки. */
@@ -54,9 +50,9 @@ export function splitPatch(patch) {
     const incs = [];
     const noMarkers = (v, path) => {
         if (isInc(v))
-            fail('invalid_data', `inc() внутри массива (${path.join('.')}) не поддерживается`);
+            throw lerr('write.inc_in_array', { path: path.join('.') });
         if (isOp(v))
-            fail('invalid_data', `оператор фильтра в данных (${path.join('.')}) — данные записываются значениями`);
+            throw lerr('write.op_in_data', { path: path.join('.') });
         if (Array.isArray(v))
             v.forEach((x, i) => noMarkers(x, [...path, String(i)]));
         else if (isPlain(v))
@@ -71,13 +67,13 @@ export function splitPatch(patch) {
             const p = [...path, k];
             if (isInc(v)) {
                 if (!Number.isFinite(v.by))
-                    fail('invalid_data', `inc(${v.by}) по пути ${p.join('.')}: величина — конечное число`);
+                    throw lerr('write.inc_by_not_finite', { by: v.by, path: p.join('.') });
                 if (v.start !== undefined && !Number.isFinite(v.start))
-                    fail('invalid_data', `inc: start по пути ${p.join('.')} — конечное число`);
+                    throw lerr('write.inc_start_not_finite', { path: p.join('.') });
                 incs.push({ path: p, by: v.by, ...(v.start !== undefined ? { start: v.start } : {}) });
             }
             else if (isOp(v)) {
-                fail('invalid_data', `оператор фильтра в патче (${p.join('.')}) — update записывает значения`);
+                throw lerr('write.op_in_patch', { path: p.join('.') });
             }
             else if (Array.isArray(v)) {
                 noMarkers(v, p);
@@ -101,15 +97,15 @@ export function splitPatch(patch) {
 // ---------------------------------------------------------------------------
 // Проверки до отправки (precheckPlan)
 // ---------------------------------------------------------------------------
-/** Данные create/upsert: объект без маркеров; ранняя проверка валидатором на TypeScript (full — объект целиком). */
-function checkFullData(cls, data, verb, full = true) {
+/** Данные create/upsert: объект без маркеров; ранняя проверка валидатором на TypeScript. */
+function checkFullData(cls, data, verb) {
     if (!isPlain(data))
-        fail('invalid_data', `${verb}(): данные — объект`);
+        throw lerr('write.data_not_object', { verb });
     const scan = (v, path) => {
         if (isInc(v))
-            fail('invalid_data', `inc() работает только в update(): ${verb}() по пути ${path.join('.')}`);
+            throw lerr('write.inc_outside_update', { verb, path: path.join('.') });
         if (isOp(v))
-            fail('invalid_data', `оператор фильтра в данных ${verb}() (${path.join('.')}) — данные записываются значениями`);
+            throw lerr('write.op_in_verb_data', { verb, path: path.join('.') });
         if (Array.isArray(v))
             v.forEach((x, i) => scan(x, [...path, String(i)]));
         else if (isPlain(v))
@@ -117,33 +113,45 @@ function checkFullData(cls, data, verb, full = true) {
                 scan(x, [...path, k]);
     };
     scan(data, []);
-    // агрегатные поля считает база (план 1.1, §2.4): переданное значение — aggregate_field до отправки, а для ранней
-    // проверки поле — 0, как его поставит база
-    const obj = data;
-    const agg = aggregateFields(cls);
-    const given = agg.filter((f) => f in obj);
-    if (given.length)
-        fail('aggregate_field', `поля ${given.join(', ')} класса ${cls.name} считает база (aggregate) — их не передают`);
     // описания системных классов проверяет только база (метасхема Class, class_admit)
-    if (!full || cls.name === 'Class' || cls.abstract)
+    if (cls.name === 'Class' || cls.abstract)
         return;
-    const issues = cls.validator()(applyDefaults(cls.schema, agg.length ? { ...obj, ...Object.fromEntries(agg.map((f) => [f, 0])) } : obj));
+    const issues = cls.validator()(applyDefaults(cls.schema, data));
     if (issues.length)
         throw new ValidationError(cls.name, issues);
 }
-/** Патч update не трогает агрегатные поля класса шага (план 1.1, §2.4): их считает база. */
-function checkAggregatePatch(cls, patch) {
-    const given = aggregateFields(cls).filter((f) => f in patch);
-    if (given.length)
-        fail('aggregate_field', `поля ${given.join(', ')} класса ${cls.name} считает база (aggregate) — update их не меняет`);
+/** Фильтр шага сужает цели: id, список id, оператор, строка ответа, объект хотя бы с одним заданным полем. */
+const narrowingFilter = (f) => f !== undefined && f !== null && (typeof f !== 'object' || Array.isArray(f) || isOp(f) || Object.values(f).some((v) => v !== undefined));
+/**
+ * Цели глагола шага i сужены (план 2.0, этап 4, п. 2; 7.10 №2): у него или у шага до него есть фильтр, id, tags()
+ * (пустой список подходит любой строке), owner() или limit(), либо до него был create() или upsert() — дальше путь
+ * идёт от записанных строк.
+ */
+function narrowed(steps, i) {
+    for (let j = 0; j <= i; j++) {
+        const s = steps[j];
+        if (narrowingFilter(s.filter) || s.ownerFilter !== undefined || s.opMods?.limit !== undefined)
+            return true;
+        if (s.tagsFilter !== undefined && s.tagsFilter !== null && !(Array.isArray(s.tagsFilter) && !s.tagsFilter.length))
+            return true;
+        if (j < i && (s.op?.kind === 'create' || s.op?.kind === 'upsert'))
+            return true;
+    }
+    return false;
 }
-/** Всё, что проверяется без базы, — до отправки первого оператора (§2.5). */
-export function precheckPlan(reg, steps) {
+/**
+ * Всё, что проверяется без базы, — до отправки первого оператора (§2.5). Фильтры шагов и поля sort() и агрегатов
+ * (неизвестное поле — invalid_query, план 2.0, этап 3, п. 3) — precheckStep построителя; order и agg — модификатор и
+ * агрегат чтения за последним глаголом (терминал цепочки).
+ */
+export function precheckPlan(reg, steps, order, agg) {
     let prevOp;
     for (let i = 0; i < steps.length; i++) {
         const s = steps[i];
         const op = s.op;
+        const tail = i === steps.length - 1;
         if (!op) {
+            precheckStep(reg, s, tail ? order : undefined, tail ? agg : undefined);
             prevOp = undefined;
             continue;
         }
@@ -152,64 +160,54 @@ export function precheckPlan(reg, steps) {
             checkReason(op.reason, `${verb}()`);
         const m = s.opMods ?? {};
         if (m.asOf !== undefined)
-            fail('invalid_query', `${verb}(): asOf описывает прошлое — записывать в него нельзя`);
-        // restore и purge сами ищут удалённые объекты шага
-        if (m.withDeleted && verb !== 'restore' && verb !== 'purge')
-            fail('invalid_query', `${verb}(): withDeleted описывает удалённые — записывать в них нельзя`);
+            throw lerr('write.as_of_write', { verb });
+        // restore сам ищет удалённые объекты шага
+        if (m.withDeleted && verb !== 'restore')
+            throw lerr('write.with_deleted_write', { verb });
         switch (op.kind) {
             case 'create':
             case 'upsert':
                 if (s.self)
-                    fail('invalid_query', `${verb}() сразу после ${prevOp?.kind}() — между глаголами нужен шаг`);
+                    throw lerr('write.verb_after_verb', { verb, prev: prevOp?.kind });
                 if (s.pivotKey !== undefined)
-                    fail('invalid_query', `${verb}() на возврате к узлу — он ведёт к существующей сущности, используйте update()`);
+                    throw lerr('write.create_on_pivot', { verb });
                 if (s.filter !== undefined && typeof s.filter !== 'string') {
-                    fail('invalid_query', `${verb}() не ищет: ${s.name}(id).${verb}(…) задаёт id, поиск — это update()`);
+                    throw lerr('write.create_with_filter', { verb, step: s.name });
                 }
                 if (op.kind === 'upsert' && !s.cls.key.length)
-                    fail('no_key', `upsert(): у класса ${s.cls.name} нет ключа — сравнивать не с чем, используйте create()`);
+                    throw lerr('write.upsert_no_key', { cls: s.cls.name });
                 checkFullData(s.cls, op.data, verb);
                 if (s.tagsFilter !== undefined && typeof s.tagsFilter !== 'string' && !Array.isArray(s.tagsFilter)) {
-                    fail('invalid_query', `.tags() перед ${verb}() — строка или список`);
+                    throw lerr('write.bad_tags', { verb });
                 }
                 break;
             case 'update':
                 if (!isPlain(op.data))
-                    fail('invalid_data', 'update(): патч — объект');
+                    throw lerr('write.patch_not_object');
                 splitPatch(op.data);
-                checkAggregatePatch(s.cls, op.data);
                 if (op.rev !== undefined && (!Number.isInteger(op.rev) || op.rev < 1))
-                    fail('invalid_query', 'update(patch, { rev }): rev — номер версии строки');
-                break;
-            case 'anonymize': {
-                if (!Array.isArray(op.fields) || !op.fields.length)
-                    fail('invalid_query', 'anonymize(поля): нужен список полей');
-                for (const f of op.fields) {
-                    const t = reg.leafType(s.cls.name, [f]);
-                    if (t !== 'text')
-                        fail('invalid_query', `anonymize() затирает только строковые поля; ${f} — ${t}`);
+                    throw lerr('write.bad_rev');
+                // строгий режим (план 2.0, этап 4, п. 2; 7.10 №2): правка без сужения целей — отказ до записи, все строки —
+                // { all: true }; data.id у шага без фильтра — тоже цель (updateOp)
+                if (!op.all && !(s.filter === undefined && typeof op.data.id === 'string') && !narrowed(steps, i)) {
+                    throw lerr('write.no_filter', { call: 'update()', cls: s.cls.name });
                 }
                 break;
-            }
-            case 'reclass':
-                reg.resolve(op.cls);
-                if (op.data !== undefined)
-                    checkFullData(reg.resolve(op.cls), op.data, 'reclass');
-                break;
             case 'delete':
-            case 'restore':
-            case 'purge':
+                // превью (без confirm) ничего не удаляет — его не сужают
+                if (op.confirm && !op.all && !narrowed(steps, i))
+                    throw lerr('write.no_filter', { call: 'delete({ confirm: true })', cls: s.cls.name });
                 break;
-            case 'rekey':
-                if (!s.cls.key.length)
-                    fail('no_key', `rekey(): у класса ${s.cls.name} нет ключа — id выдаёт база, менять нечего`);
-                checkFullData(s.cls, op.data, 'rekey', false);
+            case 'restore':
                 break;
         }
         for (const sl of s.slots ?? []) {
             if (op.kind !== 'create' && op.kind !== 'update' && op.kind !== 'upsert')
-                fail('invalid_query', `слот .${sl.role} после ${verb}() — слоты у create(), update() и upsert()`);
+                throw lerr('write.slot_bad_verb', { role: sl.role, verb });
         }
+        precheckStep(reg, s, s.opMods?.order);
+        if (tail && (order !== undefined || agg !== undefined))
+            precheckStep(reg, s, order, agg);
         prevOp = op;
     }
 }
@@ -225,7 +223,7 @@ const quoteId = (name) => `"${name.replace(/"/g, '""')}"`;
 /** Строка ответа в том же виде, что у чтения (to_jsonb колонок узла). */
 const rowJson = (a) => `jsonb_build_object('id', ${a}.id, 'rev', ${a}.rev, 'class', ${a}.class, 'tenant', ${a}.tenant, 'owner', ${a}.owner, `
     + `'links', ${a}.links, 'data', ${a}.data, 'tags', ${a}.tags, 'at', ${a}.at, 'author', ${a}.author, 'agent', ${a}.agent, `
-    + `'op', ${a}.op, 'reason', ${a}.reason, 'moved', ${a}.moved)`;
+    + `'op', ${a}.op, 'reason', ${a}.reason)`;
 async function query(w, text, params) {
     return (await w.q.unsafe(text, params, { prepare: true }));
 }
@@ -251,16 +249,18 @@ export function slotRole(reg, owner, name) {
         return name;
     const c = reg.find(name);
     if (!c)
-        fail('invalid_class', `класс или роль ${name} не найдены`);
+        throw lerr('write.slot_unknown', { name });
     const roles = rolesAccepting(reg, owner, c.name);
     if (roles.length === 1)
         return roles[0];
     if (!roles.length)
-        fail('invalid_query', `${name} — не конец класса ${owner.name} (концы: ${Object.keys(owner.ends).join(', ') || '—'})`);
-    return fail('invalid_query', `слот ${name} у класса ${owner.name} неоднозначен: роли ${roles.join(', ')} — назовите роль`);
+        throw lerr('write.slot_not_end', { name, cls: owner.name, ends: Object.keys(owner.ends).join(', ') || '—' });
+    throw lerr('write.slot_ambiguous', { name, cls: owner.name, roles: roles.join(', ') });
 }
 /** Неоднозначная роль конца из пути. */
-const ambiguous = (step, target, roles) => fail('invalid_query', `конец класса ${target.name} для шага ${step.name} неоднозначен: роли ${roles.join(', ')} — назовите шаг ролью или задайте слот`);
+const ambiguous = (step, target, roles) => {
+    throw lerr('write.end_ambiguous', { cls: target.name, step: step.name, roles: roles.join(', ') });
+};
 /**
  * Роль из нескольких кандидатов: роли, заданные слотами, не участвуют; из оставшихся — роль с именем
  * класса шага (duty.Member для шага Member, а Backup — слотом). Иначе — неоднозначно.
@@ -314,7 +314,7 @@ async function pathEnds(w, steps, taken) {
         else {
             const rows = await readRows(w, steps.slice(0, k + 1).map(bare), { limit: 2 });
             if (rows.length !== 1)
-                fail('invalid_query', `шаг ${s.name} должен дать ровно одну сущность для конца ${tcls.name} (найдено ${rows.length})`);
+                throw lerr('write.end_not_single', { step: s.name, cls: tcls.name, count: rows.length });
             id = rows[0].id;
             if (!roles) {
                 roles = pickRole(s, tcls, rolesAccepting(w.reg, tcls, rows[0].class), taken, rows[0].class);
@@ -343,9 +343,17 @@ async function slotIds(w, v) {
     if (Array.isArray(v))
         return v;
     if ('plan' in v) {
-        const rows = v.plan.some((s) => s.op)
-            ? (await execPlan(w, v.plan, v.mods, 'rows')).rows
-            : await readRows(w, v.plan, v.mods);
+        let rows;
+        if (v.plan.some((s) => s.op)) {
+            // вложенный план — те же проверки до базы, что у плана терминала; с читающим хвостом после глагола execPlan
+            // отдаёт строки чтения (план 2.0, 7.2 №3: раньше — TypeError)
+            precheckPlan(w.reg, v.plan);
+            const r = await execPlan(w, v.plan, v.mods, 'rows');
+            rows = r.kind === 'rows' ? r.rows : r.res;
+        }
+        else {
+            rows = await readRows(w, v.plan, v.mods);
+        }
         return rows.map((r) => r.id);
     }
     return [v.id];
@@ -357,7 +365,7 @@ async function resolveSlots(w, cls, slots) {
         const end = cls.ends[sl.role];
         const ids = sl.op === 'unset' ? [] : await slotIds(w, sl.value);
         if (sl.op === 'set' && sl.value !== null && !end.many && ids.length !== 1) {
-            fail('invalid_query', `слот .${sl.role}.set(): конец одиночный, а значение дало ${ids.length} сущностей`);
+            throw lerr('write.slot_single_many', { role: sl.role, count: ids.length });
         }
         out.push({ role: sl.role, op: sl.op, value: sl.op === 'unset' || sl.value === null ? null : end.many ? ids : ids[0] });
     }
@@ -394,7 +402,8 @@ function existsError(w, cls, data, links, given, cause) {
             id = undefined;
         }
     }
-    return Object.assign(new LetopisError('exists', `объект класса ${cls.name} уже существует${id ? ` (id ${id})` : ''}`, { id: id ?? null }), { cause });
+    const detail = { id: id ?? null };
+    return id ? lerr('write.exists_id', { cls: cls.name, id }, { detail, cause }) : lerr('write.exists', { cls: cls.name }, { detail, cause });
 }
 const isPkConflict = (e) => {
     const err = e;
@@ -408,16 +417,11 @@ async function createOp(w, steps, opStep, upsert) {
     const links = applySlotsLocal(await pathEnds(w, steps, new Set(slots.map((x) => x.role))), slots);
     const given = typeof opStep.filter === 'string' ? opStep.filter : undefined;
     const owner = opStep.ownerFilter ?? w.owner ?? null;
-    // агрегатные поля (план 1.1, §2.4): в excluded их поставил триггер вставки (0) — замена данных идёт без них, и
-    // триггер правки возвращает прежние значения
-    const agg = aggregateFields(cls);
-    const conflict = upsert
-        ? ` on conflict (id) do update set data = excluded.data${agg.length ? ' - $7::text[]' : ''}, links = excluded.links, tags = excluded.tags`
-        : '';
+    const conflict = upsert ? ' on conflict (id) do update set data = excluded.data, links = excluded.links, tags = excluded.tags' : '';
     const text = `insert into ${S}.entity (id, class, links, data, tags, owner) values ($1::uuid, $2::text, $3::jsonb, $4::jsonb, $5::text[], $6::uuid)`
         + `${conflict} returning old.rev as old_rev, ${rowJson('new')} as row`;
     try {
-        const res = await query(w, text, [given ?? null, cls.name, links, op.data, tagsValue(opStep), owner, ...(upsert && agg.length ? [agg] : [])]);
+        const res = await query(w, text, [given ?? null, cls.name, links, op.data, tagsValue(opStep), owner]);
         return res.map((r) => {
             const row = toRow(r.row);
             if (upsert)
@@ -438,12 +442,17 @@ async function createOp(w, steps, opStep, upsert) {
 async function explainMissing(w, missing, rev) {
     const S = quoteId(w.schema);
     const seen = await query(w, `select id, rev from ${S}.entity where id = any ($1::uuid[])`, [missing]);
-    if (!seen.length)
-        return fail('target_not_found', missing.length === 1 ? `цель ${missing[0]} не найдена` : `цели не найдены: ${missing.join(', ')}`, { ids: missing });
+    if (!seen.length) {
+        throw missing.length === 1
+            ? lerr('write.target_missing', { id: missing[0] }, { detail: { ids: missing } })
+            : lerr('write.targets_missing', { ids: missing.join(', ') }, { detail: { ids: missing } });
+    }
     if (rev !== undefined && seen.some((r) => r.rev !== rev)) {
-        return fail('conflict', `строку ${seen[0].id} успели изменить: версия ${seen[0].rev}, а не ${rev} — перечитайте и повторите`, { id: seen[0].id, rev: seen[0].rev, expected: rev });
+        const detail = { id: seen[0].id, rev: seen[0].rev, expected: rev };
+        throw lerr('write.rev_conflict', detail, { detail });
     }
-    return fail('acl_denied', `строки видны, но изменить их нельзя: ${seen.map((r) => r.id).join(', ')}`, { ids: seen.map((r) => r.id) });
+    const ids = seen.map((r) => r.id);
+    throw lerr('write.rows_denied', { ids: ids.join(', ') }, { detail: { ids } });
 }
 /**
  * Строки ответа глагола — в порядке целей (`targetIds`: по `sort()` до глагола, иначе по id). `update … returning`
@@ -453,14 +462,14 @@ function inTargetOrder(ids, rows) {
     const pos = new Map(ids.map((id, i) => [id, i]));
     return rows.sort((a, b) => (pos.get(a.id) ?? 0) - (pos.get(b.id) ?? 0));
 }
-/** Цели update/delete/anonymize/reclass: id из пути (limit и sort сужают); data.id — если у шага нет фильтра. */
+/** Цели update и delete: id из пути (limit и sort сужают); data.id — если у шага нет фильтра. */
 async function targetIds(w, steps, opStep, dataId) {
     const path = steps.map(bare);
     if (opStep.filter === undefined && dataId !== undefined)
         path[path.length - 1] = { ...path[path.length - 1], filter: dataId };
     const ids = await readIds(w, path, opStep.opMods ?? {});
-    // без явного порядка — по id: глаголы по списку целей (reclass, rekey и др.) пишут журнал по очереди, и порядок
-    // записей не должен зависеть от плана чтения
+    // без явного порядка — по id: глаголы по списку целей пишут журнал по очереди, и порядок записей не должен
+    // зависеть от плана чтения
     return opStep.opMods?.order ? ids : [...ids].sort();
 }
 async function updateOp(w, steps, opStep) {
@@ -472,9 +481,9 @@ async function updateOp(w, steps, opStep) {
     const ids = await targetIds(w, steps, opStep, useDataId ? dataId : undefined);
     if (op.rev !== undefined) {
         if (ids.length > 1)
-            fail('rev_ambiguous', `update(patch, { rev }): у шага ${opStep.name} ${ids.length} целей — проверить версию { rev } можно только у одной цели`);
+            throw lerr('write.rev_many_targets', { step: opStep.name, count: ids.length });
         if (!ids.length)
-            fail('target_not_found', `update(patch, { rev }): у шага ${opStep.name} нет цели`);
+            throw lerr('write.rev_no_target', { step: opStep.name });
     }
     if (!ids.length)
         return [];
@@ -539,40 +548,13 @@ async function deleteOp(w, steps, opStep) {
     }
     return out;
 }
-async function anonymizeOp(w, steps, opStep) {
-    const op = opStep.op;
-    const S = quoteId(w.schema);
-    const ids = await targetIds(w, steps, opStep);
-    if (!ids.length)
-        return [];
-    const res = await query(w, `update ${S}.entity e set data = e.data || coalesce((select jsonb_object_agg(f, '[erased]'::text) from unnest($2::text[]) f where e.data ? f), '{}'::jsonb), `
-        + `tags = (select array_agg(distinct t order by t) from unnest(e.tags || array['anonymized']) t) `
-        + `where e.id = any ($1::uuid[]) returning ${rowJson('new')} as row`, [ids, op.fields]);
-    if (res.length < ids.length) {
-        const got = new Set(res.map((r) => r.row.id));
-        await explainMissing(w, ids.filter((x) => !got.has(x)));
-    }
-    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
-}
-async function reclassOp(w, steps, opStep) {
-    const op = opStep.op;
-    const S = quoteId(w.schema);
-    const ids = await targetIds(w, steps, opStep);
-    if (!ids.length)
-        return [];
-    const cls = w.reg.resolve(op.cls).name;
-    // у класса без ключа id сохраняется, у класса с ключом — новый id и перевод ссылок (reclass() в базе)
-    const moved = await query(w, `select ${S}.reclass(x, $2::text, $3::jsonb) as id from unnest($1::uuid[]) with ordinality as u(x, i) order by u.i`, [ids, cls, op.data ?? null]);
-    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[])`, [moved.map((m) => m.id)]);
-    return res.map((r) => toRow(r.row));
-}
-/** Удалённые объекты шага (restore, purge): живые цели без удалённых — not_deleted. */
+/** Удалённые объекты шага (restore): живые цели без удалённых — not_deleted. */
 async function deletedTargets(w, steps, opStep, verb) {
     const rows = await readRows(w, steps.map(bare), { ...(opStep.opMods ?? {}), withDeleted: true });
     const dead = rows.filter((r) => r.$deleted);
     if (!dead.length && rows.length)
-        fail('not_deleted', `объект не удалён: ${verb}() — только для удалённых${verb === 'purge' ? ', сначала delete()' : ''}`, { ids: rows.map((r) => r.id) });
-    // без явного порядка — по id: restore и purge пишут журнал по очереди целей
+        throw lerr('write.not_deleted', { verb }, { detail: { ids: rows.map((r) => r.id) } });
+    // без явного порядка — по id: restore пишет журнал по очереди целей
     return opStep.opMods?.order ? dead : [...dead].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
 }
 /** Восстановление (этап 6, п. 2): последний снимок новой версией; база перепроверяет его по текущему описанию. */
@@ -583,54 +565,8 @@ async function restoreOp(w, steps, opStep) {
         return [];
     const ids = dead.map((r) => r.id);
     await query(w, `select ${S}.restore(x) from unnest($1::uuid[]) with ordinality as u(x, i) order by u.i`, [ids]);
-    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[]) order by e.id`, [ids]);
-    return res.map((r) => toRow(r.row));
-}
-/**
- * Стирание истории удалённых (этап 6, п. 3): без { confirm: true } — превью (надгробия и число
- * версий $versions), с ним — версии стёрты, на месте версии 1 — запись purge ($purged).
- */
-async function purgeOp(w, steps, opStep) {
-    const op = opStep.op;
-    const S = quoteId(w.schema);
-    const dead = await deletedTargets(w, steps, opStep, 'purge');
-    const out = [];
-    for (const row of dead) {
-        const [{ r }] = await query(w, `select ${S}.purge($1::uuid, $2::boolean) as r`, [row.id, op.confirm]);
-        out.push({ ...row, $versions: r.versions, ...(r.purged ? { $purged: true } : {}) });
-    }
-    return out;
-}
-/** Новое значение ключа (этап 6, п. 7): строка с новым id, ссылки переведены, журнал связывает id. */
-async function rekeyOp(w, steps, opStep) {
-    const op = opStep.op;
-    const S = quoteId(w.schema);
-    const ids = await targetIds(w, steps, opStep);
-    if (!ids.length)
-        return [];
-    // поля — в данные, роли концов — в концы
-    const data = {};
-    const links = {};
-    for (const [k, v] of Object.entries(op.data)) {
-        if (opStep.cls.ends[k])
-            links[k] = typeof v === 'object' && v !== null && !Array.isArray(v) ? v.id : v;
-        else
-            data[k] = v;
-    }
-    const moved = [];
-    for (const id of ids) {
-        try {
-            const [{ id: nid }] = await query(w, `select ${S}.rekey($1::uuid, $2::jsonb, $3::jsonb) as id`, [id, data, links]);
-            moved.push(nid);
-        }
-        catch (e) {
-            if (isPkConflict(e))
-                throw Object.assign(new LetopisError('exists', `rekey(): объект класса ${opStep.cls.name} с таким ключом уже существует`, { id }), { cause: e });
-            throw e;
-        }
-    }
-    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[]) order by e.id`, [moved]);
-    return res.map((r) => toRow(r.row));
+    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[])`, [ids]);
+    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
 async function opCall(w, steps, opStep) {
     await useReason(w, reasonFor(w, opStep));
@@ -639,11 +575,7 @@ async function opCall(w, steps, opStep) {
         case 'upsert': return createOp(w, steps, opStep, true);
         case 'update': return updateOp(w, steps, opStep);
         case 'delete': return deleteOp(w, steps, opStep);
-        case 'anonymize': return anonymizeOp(w, steps, opStep);
-        case 'reclass': return reclassOp(w, steps, opStep);
         case 'restore': return restoreOp(w, steps, opStep);
-        case 'purge': return purgeOp(w, steps, opStep);
-        case 'rekey': return rekeyOp(w, steps, opStep);
     }
 }
 /** Разрезать план: сегменты (…шаги + шаг с глаголом) и читающий хвост после последнего глагола. */
@@ -700,18 +632,17 @@ export async function execPlan(w, steps, mods, mode, agg) {
         else {
             last = await opCall(w, [fromRows(prevOp, start.map((r) => r.id)), ...seg.steps], opStep);
         }
-        // после удаления продолжение — от удалённых строк класса цели (замыкание каскада шире); после
-        // стирания истории продолжать не от чего
+        // после удаления продолжение — от удалённых строк класса цели (замыкание каскада шире)
         start = kind === 'delete' && opStep.op.confirm
             ? last.filter((r) => stepClasses(w.reg, opStep).includes(r.class))
-            : kind === 'purge' ? [] : last;
+            : last;
         prevOp = opStep;
     }
     // причина глагола не переходит на следующие операторы транзакции
     await useReason(w, w.reason ?? '');
     const opStep = segments[segments.length - 1].steps.at(-1);
     const key = opStep.aliasKey ?? opStep.name;
-    if (tail.length || mode === 'versions' || mode === 'agg' || mode === 'diff' || mode === 'blame') {
+    if (tail.length || mode === 'versions' || mode === 'agg') {
         if (!start.length)
             return { kind: 'read', q: null, res: [] };
         const { q, res } = await readIn(w, [fromRows(opStep, start.map((r) => r.id)), ...tail], mods, mode, agg);
@@ -771,7 +702,9 @@ export async function execBatch(w, plans) {
                 && reasonFor(w, plans[j][0]) === why) {
                 const s = plans[j][0];
                 const id = idFor(s);
-                if (!id || (verb === 'upsert' && seen.has(id)))
+                // повтор id режет группу и у create: иначе вторая строка «находила» строку первой, и батч проходил молча
+                // (план 2.0, 7.2 №1); повтор уходит следующим оператором и получает exists
+                if (!id || seen.has(id))
                     break;
                 seen.add(id);
                 group.push({ at: j, s, id });
@@ -779,13 +712,11 @@ export async function execBatch(w, plans) {
             }
             await useReason(w, why);
             const input = group.map((g) => ({ d: g.s.op.data, t: tagsValue(g.s), o: g.s.ownerFilter ?? w.owner ?? null }));
-            // агрегатные поля — без них, как у одиночного upsert (план 1.1, §2.4)
-            const agg = aggregateFields(head.cls);
             const conflict = verb === 'upsert'
-                ? `on conflict (id) do update set data = excluded.data${agg.length ? ' - $3::text[]' : ''}, links = excluded.links, tags = excluded.tags`
+                ? 'on conflict (id) do update set data = excluded.data, links = excluded.links, tags = excluded.tags'
                 : 'on conflict (id) do nothing';
             const res = await query(w, `insert into ${S}.entity (class, data, tags, owner) select $1::text, x.d, x.t, x.o `
-                + `from jsonb_to_recordset($2::jsonb) as x(d jsonb, t text[], o uuid) ${conflict} returning old.rev as old_rev, ${rowJson('new')} as row`, [head.cls.name, input, ...(verb === 'upsert' && agg.length ? [agg] : [])]);
+                + `from jsonb_to_recordset($2::jsonb) as x(d jsonb, t text[], o uuid) ${conflict} returning old.rev as old_rev, ${rowJson('new')} as row`, [head.cls.name, input]);
             const byId = new Map(res.map((r) => [r.row.id, r]));
             for (const g of group) {
                 const r = byId.get(g.id);