letopis 1.3.0 → 1.4.1

package/dist/write.js

@@ -29,8 +29,9 @@ import { applyDefaults } from './validate.js';
 /** Метка приращения; Symbol.for — маркер узнаёт и вторая копия пакета в процессе. */
 export const INC = Symbol.for('letopis.inc');
 /**
- * Приращение в update: `update({ balance: inc(-300) })` — величина прибавляется в базе, внутри
- * оператора, над свежей строкой (функция inc). Поля нет — ошибка; `{ start }` — начать с него.
+ * Приращение числового поля в `update()`: `db.Wallet(w).update({ balance: inc(-300) })`. Сложение делает база над
+ * текущим значением поля в момент записи, поэтому одновременные приращения не теряются. Если поля ещё нет, `{ start }`
+ * задаёт, с чего начать (поле получит `start + by`), а без него — ошибка `invalid_data`.
  */
 export function inc(by, opts = {}) {
     return Object.freeze({ [INC]: true, by, ...(opts.start !== undefined ? { start: opts.start } : {}) });
@@ -377,7 +378,11 @@ function applySlotsLocal(links, ops) {
     }
     return out;
 }
-const tagsValue = (s) => s.tagsFilter === undefined ? null : typeof s.tagsFilter === 'string' ? [s.tagsFilter] : s.tagsFilter;
+/**
+ * Теги, которые пишет глагол: строка или список из `.tags(…)` (перед update они же и отбирают цели). Оператор
+ * (has, hasAny, hasAll) только отбирает — теги целей не меняются; create и upsert его не принимают (precheck).
+ */
+const tagsValue = (s) => typeof s.tagsFilter === 'string' ? [s.tagsFilter] : Array.isArray(s.tagsFilter) ? s.tagsFilter : null;
 /** «Уже существует»: id вычисляет библиотека (idOf), а не разбирает текст ошибки сервера (§2.5). */
 function existsError(w, cls, data, links, given, cause) {
     let id = given;
@@ -440,12 +445,23 @@ async function explainMissing(w, missing, rev) {
     }
     return fail('acl_denied', `строки видны, но изменить их нельзя: ${seen.map((r) => r.id).join(', ')}`, { ids: seen.map((r) => r.id) });
 }
+/**
+ * Строки ответа глагола — в порядке целей (`targetIds`: по `sort()` до глагола, иначе по id). `update … returning`
+ * отдаёт их в порядке обхода таблицы, и `first()` после глагола брал бы случайную из исправленных строк.
+ */
+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 — если у шага нет фильтра. */
 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 };
-    return readIds(w, path, opStep.opMods ?? {});
+    const ids = await readIds(w, path, opStep.opMods ?? {});
+    // без явного порядка — по id: глаголы по списку целей (reclass, rekey и др.) пишут журнал по очереди, и порядок
+    // записей не должен зависеть от плана чтения
+    return opStep.opMods?.order ? ids : [...ids].sort();
 }
 async function updateOp(w, steps, opStep) {
     const op = opStep.op;
@@ -456,7 +472,7 @@ 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} целей — строгий режим только для одной`);
+            fail('rev_ambiguous', `update(patch, { rev }): у шага ${opStep.name} ${ids.length} целей — проверить версию { rev } можно только у одной цели`);
         if (!ids.length)
             fail('target_not_found', `update(patch, { rev }): у шага ${opStep.name} нет цели`);
     }
@@ -481,7 +497,7 @@ async function updateOp(w, steps, opStep) {
         const got = new Set(res.map((r) => r.row.id));
         await explainMissing(w, ids.filter((x) => !got.has(x)), op.rev);
     }
-    return res.map((r) => toRow(r.row));
+    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
 async function deleteOp(w, steps, opStep) {
     const op = opStep.op;
@@ -510,9 +526,11 @@ async function deleteOp(w, steps, opStep) {
     }
     const tombs = await query(w, `select ${rowJson('l')} as row from ${S}.log l where l.tx = pg_current_xact_id() and l.seq > $1::bigint and l.op = 'delete' order by l.seq`, [mark]);
     const out = tombs.map((r) => toRow(r.row));
-    // строки классов без журнала (history: false) надгробий не оставляют — берём их из returning
+    // строки классов без журнала (history: false) надгробий не оставляют — берём их из returning, по id (порядок
+    // returning зависит от плана, а итог delete() — нет: надгробия идут по seq, триггер пишет их в порядке id)
     const have = new Set(out.map((r) => r.id));
-    for (const g of gone) {
+    const byId = (a, b) => String(a.row.id) < String(b.row.id) ? -1 : String(a.row.id) > String(b.row.id) ? 1 : 0;
+    for (const g of [...gone].sort(byId)) {
         if (have.has(g.row.id))
             continue;
         const row = toRow(g.row);
@@ -534,7 +552,7 @@ async function anonymizeOp(w, steps, opStep) {
         const got = new Set(res.map((r) => r.row.id));
         await explainMissing(w, ids.filter((x) => !got.has(x)));
     }
-    return res.map((r) => toRow(r.row));
+    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
 async function reclassOp(w, steps, opStep) {
     const op = opStep.op;
@@ -554,7 +572,8 @@ async function deletedTargets(w, steps, opStep, verb) {
     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) });
-    return dead;
+    // без явного порядка — по id: restore и purge пишут журнал по очереди целей
+    return opStep.opMods?.order ? dead : [...dead].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
 }
 /** Восстановление (этап 6, п. 2): последний снимок новой версией; база перепроверяет его по текущему описанию. */
 async function restoreOp(w, steps, opStep) {

package/llms.txt

@@ -2,7 +2,7 @@
 
 > Versioned entity store for Node.js on PostgreSQL 18. Every change is a version in a journal (history, reads as of a date, cursor subscriptions). Integrity, tenant isolation and access rules are enforced by the database itself (triggers and row-level security), so they hold for raw SQL too. Data is read and written with chains like `db.Shop(shop).Product().rows()`.
 
-Key facts for writing code with letopis 1.3:
+Key facts for writing code with letopis 1.4:
 
 - ESM package, Node 22+, PostgreSQL 18+ with pgcrypto, database encoding UTF8. Runtime dependency: `postgres`. Zod 4 is an optional peer dependency needed only by `letopis/model`; `@modelcontextprotocol/server`, only by `letopis/mcp`.
 - Install a schema with `up({ dsn, schema })` from an admin role; the schema is named `v2.<name>`. The application connects with a LOGIN role that is a member of `letopis_app`: `connect({ dsn, schema: 'v2.<name>', token | apiKey })`. A role that bypasses RLS is refused (`bypass_rls`) unless `allowBypassRls: true`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letopis",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Letopis (летопись): versioned entity store on PostgreSQL 18 — integrity, history, tenants and access control enforced by the database itself, dot-notation chains on top",
   "keywords": [
     "postgres",

package/sql/10-core.sql

@@ -107,9 +107,12 @@ create index if not exists log_ends on @SCHEMA@.log using gin (@SCHEMA@.link_ids
 -- журнал часто прореживается (§2.11): чаще чистим
 alter table @SCHEMA@.log set (autovacuum_vacuum_scale_factor = 0.02, autovacuum_analyze_scale_factor = 0.02);
 
+-- account — строка entity (аккаунт; у служебных строк KEY, LOCK, PROJECTOR — System): удалённый аккаунт уносит свои строки
+-- каскадом внешнего ключа — сессии, хэши паролей и ключей, секреты TOTP, внешние учётные записи (ревизия 7; в схему
+-- прежней ревизии ключ добавляет миграция 0007). Строка Account у System не удаляется (trg_entity_bd_account, 60-write.sql)
 create table if not exists @SCHEMA@.secret (
   id          uuid primary key default gen_random_uuid(),
-  account     uuid not null,
+  account     uuid not null constraint secret_account_fkey references @SCHEMA@.entity (id) on delete cascade,
   kind        text not null,       -- PASSWORD, APIKEY, KEYSECRET, OTP, TOTP, IDENTITY, SESSION
   ident       text,                -- email, телефон, префикс ключа, внешний id
   material    bytea,               -- хэш пароля, ключа, кода или токена; секрет TOTP
@@ -121,6 +124,8 @@ create table if not exists @SCHEMA@.secret (
 create unique index if not exists secret_kind_ident on @SCHEMA@.secret (kind, casefold(ident) collate pg_unicode_fast)
   where deleted_at is null and ident is not null;
 create index if not exists secret_material on @SCHEMA@.secret (material) where kind = 'SESSION' and deleted_at is null;
+-- строки аккаунта: каскад внешнего ключа при удалении аккаунта и гашение его сессий (auth_kill) — без перебора таблицы
+create index if not exists secret_account on @SCHEMA@.secret (account);
 
 alter table @SCHEMA@.entity owner to @OWNER@;
 alter table @SCHEMA@.log owner to @OWNER@;

package/sql/50-acl.sql

@@ -228,9 +228,13 @@ begin
                                         and jsonb_typeof(x.pattern->'class') <> 'string', false) as bad) m
     where x.deny or not m.bad
   ), cl as (
-    select c.data->>'name' as name, c.data->>'alias' as alias, c.data->'resolved'->'ancestors' as anc
+    -- один класс на имя — тот, что строки арендатора находят по имени (class_row): свой, иначе System. Одноимённый
+    -- класс System, заведённый после класса арендатора, в план не входит: его предки и алиас давали бы права на строки
+    -- класса арендатора (хвост ревью доработок после 1.2.0)
+    select distinct on (c.data->>'name') c.data->>'name' as name, c.data->>'alias' as alias, c.data->'resolved'->'ancestors' as anc
     from @SCHEMA@.entity c
     where c.class = 'Class' and c.tenant in (p_tenant, '@SYSTEM@'::uuid)
+    order by c.data->>'name', c.tenant = '@SYSTEM@'::uuid
   ), k as (
     select cl.name,
            array(select jsonb_array_elements_text(cl.anc))

package/sql/60-write.sql

@@ -760,6 +760,14 @@ begin
       perform @SCHEMA@.lt_fail('invalid_class', format('имя %s занято системным классом', p_data->>'name'));
     end if;
   end if;
+  -- родитель — под разделяемой блокировкой своего семейства (хвост ревью доработок после 1.2.0): удаление класса берёт
+  -- исключительную, поэтому родитель не удалится мимо нового потомка, а удалённый, пока ждали, class_prepare не найдёт
+  if p_data->>'parent' is not null then
+    tc := @SCHEMA@.class_row(p_data->>'parent', p_tenant);
+    if tc.id is not null then
+      perform @SCHEMA@.family_lock(tc, false);
+    end if;
+  end if;
   select c.data, c.validator into data, validator from @SCHEMA@.class_prepare(p_data, p_tenant) c;
   if data->>'kind' = 'link' and (data->>'name') = any (@SCHEMA@.reserved_names()) then
     perform @SCHEMA@.lt_fail('invalid_class', format('имя связи %s совпадает с методом цепочки', data->>'name'));
@@ -798,12 +806,15 @@ begin
       data->>'name'));
   end if;
   -- предок производного класса (ревью безопасности №3): правка предка пересчитывает описание потомка (class_evolve) —
-  -- поля, ключ, history, — поэтому класс с производными потомками (своего арендатора, у класса System — всех) меняет
-  -- тоже только администратор
+  -- поля, ключ, history, — поэтому класс с производными потомками (своего арендатора, у класса System — всех, кроме
+  -- арендаторов со своим одноимённым классом: их потомки наследуют свой класс) меняет тоже только администратор
   if prevd is not null and not @SCHEMA@.letopis_allowed('letopis.projector') then
     select x.data->>'name' into dkid from @SCHEMA@.entity x
     where x.class = 'Class' and x.data->>'name' <> data->>'name'
-      and (x.tenant = p_tenant or p_tenant = '@SYSTEM@'::uuid)
+      and (x.tenant = p_tenant
+           or p_tenant = '@SYSTEM@'::uuid
+              and x.tenant <> all (array(select y.tenant from @SCHEMA@.entity y
+                                         where y.class = 'Class' and y.data->>'name' = data->>'name' and y.tenant <> '@SYSTEM@'::uuid)))
       and x.data->'resolved'->'ancestors' ? (data->>'name') and x.data->'resolved' ? 'derivedBy'
     order by x.data->>'name' limit 1;
     if dkid is not null then
@@ -962,9 +973,12 @@ begin
   if cls.id is null then
     perform @SCHEMA@.lt_fail('invalid_class', format('класс %s не найден', NEW.class));
   end if;
-  -- разделяемая блокировка корня семейства, затем описание перечитывается под ней
+  -- разделяемая блокировка корня семейства, затем описание перечитывается под ней (класс могли удалить, пока ждали)
   perform @SCHEMA@.family_lock(cls, false);
   cls := @SCHEMA@.class_row(NEW.class, NEW.tenant);
+  if cls.id is null then
+    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', NEW.class));
+  end if;
   res := cls.data->'resolved';
   if coalesce((res->>'abstract')::boolean, false) then
     perform @SCHEMA@.lt_fail('invalid_class', format('класс %s абстрактный', NEW.class));
@@ -1091,6 +1105,9 @@ begin
   end if;
   perform @SCHEMA@.family_lock(cls, false);
   cls := @SCHEMA@.class_row(NEW.class, OLD.tenant);
+  if cls.id is null then
+    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', NEW.class));
+  end if;
   res := cls.data->'resolved';
   if coalesce((res->>'abstract')::boolean, false) then
     perform @SCHEMA@.lt_fail('invalid_class', format('класс %s абстрактный', NEW.class));
@@ -1200,7 +1217,8 @@ begin
   select n.id, n.rev, n.class, n.cv, n.tenant, n.owner, n.links, n.data, n.tags, n.at, n.author, n.agent, n.op, n.reason, n.moved, n.prev_hash
   from added n
   join (select k.class, k.tenant from (select distinct a.class, a.tenant from added a) k
-        where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant;
+        where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant
+  order by n.at, n.id;  -- порядок seq — порядок входа, а не плана соединения
   -- сигнал — по паре «класс, арендатор»
   select array_agg(k.class), array_agg(k.tenant) into sc, st from (select distinct a.class, a.tenant from added a) k;
   perform @SCHEMA@.signal(sc, st);
@@ -1212,6 +1230,10 @@ begin
     -- прав после acl_bump видит новый класс
     perform @SCHEMA@.agg_source_admit(n.data->>'name', @SCHEMA@.agg_new_mark(null, n.data->'resolved'))
     from added n where n.class = 'Class' and n.data->'resolved' ? 'aggregatedBy';
+    -- и описавшему агрегат (хвост ревью доработок после 1.2.0): заведя потомка источника, читающий всё пользователь
+    -- иначе открыл бы его строки тому, кто описал агрегат без права на них
+    perform @SCHEMA@.agg_author_admit(n.data->>'name', n.tenant, null, n.data->'resolved')
+    from added n where n.class = 'Class' and n.data->'resolved' ? 'aggregatedBy';
     -- новая цель агрегатов (план 1.1, §2.4): метки её источников (aggregatedBy) — заново
     perform @SCHEMA@.agg_mark(n.tenant, @SCHEMA@.agg_of(n.data->'resolved'))
     from added n where n.class = 'Class' and n.data->'resolved' ? 'aggregate';
@@ -1252,7 +1274,8 @@ begin
   from new_rows n
   join old_rows o on o.id = n.id and o.rev <> n.rev
   join (select k.class, k.tenant from (select distinct a.class, a.tenant from new_rows a) k
-        where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant;
+        where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant
+  order by n.id;  -- порядок seq не зависит от плана: правка многих строк пишет версии в порядке id
   -- сигнал — по парам нового и прежнего класса: при смене класса без ключа ответы прежнего класса в
   -- кэше других процессов устарели бы (в 1.0.1 сигнал шёл только по новому)
   select array_agg(k.class), array_agg(k.tenant) into sc, st
@@ -1269,6 +1292,7 @@ begin
     -- класс становится источником агрегата (смена parent; ревью коммита этапа 4б): право READ без условий на его строки
     -- и после правки — по новым предкам (до правки проверил class_admit)
     perform @SCHEMA@.agg_source_admit(n_row.data->>'name', @SCHEMA@.agg_new_mark(o_row.data->'resolved', n_row.data->'resolved'));
+    perform @SCHEMA@.agg_author_admit(n_row.data->>'name', n_row.tenant, o_row.data->'resolved', n_row.data->'resolved');
     perform @SCHEMA@.class_evolve(o_row, n_row);
   end loop;
   -- отключённый аккаунт: сессии гаснут (этап 5, п. 2), каждая — сигнал кэшу
@@ -1316,6 +1340,8 @@ begin
     if d.tenant = n.tenant then
       perform @SCHEMA@.agg_source_admit(d.data->>'name', @SCHEMA@.agg_new_mark(d.data->'resolved', prep.data->'resolved'));
     end if;
+    -- и описавшему агрегат — в объёме описания (agg_author_admit сам пропускает класс арендатора под агрегатом System)
+    perform @SCHEMA@.agg_author_admit(d.data->>'name', d.tenant, d.data->'resolved', prep.data->'resolved');
     classes := classes || (d.data->>'name');
     if d.data->'resolved'->'aggregate' is distinct from prep.data->'resolved'->'aggregate' then
       agg_names := agg_names || @SCHEMA@.agg_of(d.data->'resolved') || @SCHEMA@.agg_of(prep.data->'resolved');
@@ -1361,6 +1387,24 @@ begin
   return null;
 end $$;
 
+-- Перед удалением строки Account (ревизия 7, решение владельца). Строки secret аккаунта — сессии, хэши паролей и ключей,
+-- секреты TOTP, внешние учётные записи — уносит каскад внешнего ключа secret.account в конце оператора, раньше триггера
+-- после него, поэтому сессии гаснут с сигналом session:<хэш> здесь: процессы сбрасывают кэш ответов этих сессий.
+-- Срабатывает для всех ролей, в том числе владельца: аккаунты удаляют и функции владельца — каскад trg_entity_ad и
+-- account_purge. Строка Account у System не удаляется: ей принадлежат служебные строки secret (KEY — ключ прав и
+-- сигналов, LOCK — строки-замки, PROJECTOR — чекпоинты проекторов), которые каскад стёр бы, а без них установка не пишет.
+create or replace function @SCHEMA@.trg_entity_bd_account() returns trigger
+language plpgsql security definer
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+begin
+  if OLD.id = '@SYSTEM@'::uuid then
+    perform @SCHEMA@.lt_fail('acl_denied', 'аккаунт System не удаляется: ему принадлежат служебные строки установки');
+  end if;
+  perform @SCHEMA@.auth_kill(OLD.id, null);
+  return OLD;
+end $$;
+
 -- Действие со строкой, которая ссылается на удаляемые id (p_ids), по правилам её концов (p_ends):
 -- cascade сильнее restrict, restrict сильнее unset; null — строка на них не ссылается. Общее правило
 -- для триггера удаления и превью delete_preview() (этап 4, п. 6): превью не расходится с удалением.
@@ -1432,12 +1476,11 @@ declare
   dplan jsonb;
   wplan jsonb;
   denied text;
-  accs uuid[];
   mems jsonb;
-  lvl_accs uuid[];
   lvl_mems jsonb;
   drows jsonb;
   own uuid[];
+  cl @SCHEMA@.entity;
 begin
   select * into c from @SCHEMA@.ctx();
   -- права в замыкании (этап 5, п. 6): DELETE на каждую удаляемую каскадом строку, WRITE — на строку,
@@ -1453,6 +1496,13 @@ begin
   if denied is not null then
     perform @SCHEMA@.lt_fail('derived_class', format('класс %s производный: его строки удаляет проектор', denied));
   end if;
+  -- удаление класса (хвост ревью безопасности доработок после 1.2.0): проверки ниже — нет строк, потомков и истории —
+  -- не видят строку, которую писатель ещё не зафиксировал, и она осталась бы без класса, а с ней история удалённого
+  -- класса, от которой зависит смена алиаса предка. Писатели строк и создание потомка держат разделяемую блокировку
+  -- семейства: исключительная ждёт их, и следующие операторы проверок видят зафиксированное
+  for cl in select g.* from gone g where g.class = 'Class' order by @SCHEMA@.family_name(g.tenant, g.data), g.id loop
+    perform @SCHEMA@.family_lock(cl, true);
+  end loop;
   for r in select g.id, g.tenant, g.data->>'name' as name, g.data->'resolved' ? 'derivedBy' as derived from gone g where g.class = 'Class' loop
     -- производный класс удаляет только администратор (class_admit)
     if r.derived and not @SCHEMA@.letopis_allowed('letopis.projector') then
@@ -1494,19 +1544,21 @@ begin
   perform @SCHEMA@.agg_mark(g.tenant, @SCHEMA@.agg_of(g.data->'resolved'))
   from gone g where g.class = 'Class' and g.data->'resolved' ? 'aggregate';
   v_author := coalesce(c.author, '@SYSTEM@'::uuid);
-  -- надгробия: последний снимок следующей версией с видом delete — одной вставкой на уровень
+  -- надгробия: последний снимок следующей версией с видом delete — одной вставкой на уровень, в порядке id: без
+  -- order by порядок seq (а с ним итог delete() и время at) зависел от плана соединения и менялся от прогона к
+  -- прогону; время now_ts() (volatile) планировщик вычисляет уже после сортировки
   insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, changed)
   select g.id, g.rev + 1, g.class, g.cv, g.tenant, g.owner, g.links, g.data, g.tags,
          greatest(@SCHEMA@.now_ts(), g.at + interval '1 microsecond'), v_author, c.agent, 'delete', v_reason, null, g.hash, '[]'::jsonb
   from gone g
   join (select d.class, d.tenant from (select distinct x.class, x.tenant from gone x) d
-        where @SCHEMA@.history_on(d.class, d.tenant)) h on h.class = g.class and h.tenant = g.tenant;
+        where @SCHEMA@.history_on(d.class, d.tenant)) h on h.class = g.class and h.tenant = g.tenant
+  order by g.id;
   -- пары «класс, арендатор» для сигнала — строкой «класс арендатор» (пробела нет ни в имени, ни в uuid)
   select coalesce(array_agg(g.id), '{}'), coalesce(array_agg(distinct g.class), '{}'),
          coalesce(array_agg(distinct g.class || ' ' || g.tenant::text), '{}'),
-         coalesce(array_agg(g.id) filter (where g.class = 'Account'), '{}'),
          coalesce(jsonb_agg(jsonb_build_object('tenant', g.tenant, 'user', g.links->>'User')) filter (where g.class = 'member'), '[]'::jsonb)
-    into lvl, classes, pairs, accs, mems from gone g;
+    into lvl, classes, pairs, mems from gone g;
   all_ids := lvl;
   while cardinality(lvl) > 0 loop
     -- кто ссылается на уровень: действие по правилам концов (общее с превью)
@@ -1534,20 +1586,19 @@ begin
       from d
       join (select dd.class, dd.tenant from (select distinct x.class, x.tenant from d x) dd
             where @SCHEMA@.history_on(dd.class, dd.tenant)) h on h.class = d.class and h.tenant = d.tenant
+      order by d.id  -- надгробия уровня в порядке id, как и на уровне 0
     )
     select coalesce(array_agg(d.id), '{}'), coalesce(array_agg(distinct d.class), '{}'),
            coalesce(array_agg(distinct d.class || ' ' || d.tenant::text), '{}'),
            jsonb_agg(to_jsonb(d)) filter (where not @SCHEMA@.acl_row_ok(dplan, d.class, d.id, d.owner, d.tenant, d.tags, d.data, d.links)),
-           coalesce(array_agg(d.id) filter (where d.class = 'Account'), '{}'),
            coalesce(jsonb_agg(jsonb_build_object('tenant', d.tenant, 'user', d.links->>'User')) filter (where d.class = 'member'), '[]'::jsonb)
-      into lvl, lvl_classes, lvl_pairs, drows, lvl_accs, lvl_mems from d;
+      into lvl, lvl_classes, lvl_pairs, drows, lvl_mems from d;
     -- класс отказавшей строки называется, только если актор её видит (ревью безопасности №3)
     if drows is not null then
       denied := @SCHEMA@.visible_class(drows);
       perform @SCHEMA@.lt_fail('acl_denied', case when denied is not null then format('нет права DELETE на класс %s в каскаде удаления', denied)
                                                    else 'нет права DELETE на строки в каскаде удаления' end);
     end if;
-    accs := accs || lvl_accs;
     mems := mems || lvl_mems;
     classes := classes || lvl_classes;
     pairs := pairs || lvl_pairs;
@@ -1573,14 +1624,11 @@ begin
   end loop;
   -- выход из членства (и удаление аккаунта, которое снимает его членства): строки арендатора, которыми
   -- владел участник, переходят арендатору (§2.10) — новой версией
-  for r in select distinct (m->>'tenant')::uuid as tenant, (m->>'user')::uuid as usr from jsonb_array_elements(mems) m loop
+  for r in select distinct (m->>'tenant')::uuid as tenant, (m->>'user')::uuid as usr from jsonb_array_elements(mems) m order by 1, 2 loop
     perform @SCHEMA@.owner_to_tenant(r.tenant, r.usr);
   end loop;
-  -- удалённый аккаунт: сессии гаснут, креды удаляются (идентификаторы освобождаются)
-  for r in select distinct u as acc from unnest(accs) u loop
-    perform @SCHEMA@.auth_kill(r.acc, null);
-    update @SCHEMA@.secret x set deleted_at = clock_timestamp() where x.account = r.acc and x.deleted_at is null;
-  end loop;
+  -- удалённый аккаунт (ревизия 7): сессии погасил с сигналом триггер до удаления (trg_entity_bd_account), его строки
+  -- secret стёр каскад внешнего ключа secret.account — идентификаторы входа свободны
   perform @SCHEMA@.signal(array_agg(split_part(x.p, ' ', 1)), array_agg(split_part(x.p, ' ', 2)::uuid))
   from (select distinct p from unnest(pairs) p) x;
   if classes && array['rule', 'Resource', 'member', 'Account', 'Class'] then
@@ -1668,6 +1716,9 @@ create or replace trigger entity_au after update on @SCHEMA@.entity referencing
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_au();
 create or replace trigger entity_bd before delete on @SCHEMA@.entity
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_bd();
+-- удаление аккаунта — для всех ролей, в том числе владельца (каскад trg_entity_ad, account_purge): ревизия 7
+create or replace trigger entity_bd_account before delete on @SCHEMA@.entity
+  for each row when (OLD.class = 'Account') execute function @SCHEMA@.trg_entity_bd_account();
 create or replace trigger entity_ad after delete on @SCHEMA@.entity referencing old table as gone
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_ad();
 -- в режиме репликации (session_replication_role = replica) триггеры тоже работают
@@ -1676,6 +1727,7 @@ alter table @SCHEMA@.entity enable always trigger entity_bu;
 alter table @SCHEMA@.entity enable always trigger entity_ai;
 alter table @SCHEMA@.entity enable always trigger entity_au;
 alter table @SCHEMA@.entity enable always trigger entity_bd;
+alter table @SCHEMA@.entity enable always trigger entity_bd_account;
 alter table @SCHEMA@.entity enable always trigger entity_ad;
 
 -- ========================= смена класса с ключом =========================
@@ -1808,6 +1860,9 @@ begin
   end if;
   perform @SCHEMA@.family_lock(cls, false);
   cls := @SCHEMA@.class_row(p_class, o.tenant);
+  if cls.id is null then
+    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', p_class));
+  end if;
   res := cls.data->'resolved';
   if coalesce((res->>'abstract')::boolean, false) then
     perform @SCHEMA@.lt_fail('invalid_class', format('класс %s абстрактный', p_class));
@@ -1995,7 +2050,7 @@ begin
     'incoming_conflicts(uuid, text, uuid)', 'visible_detail(jsonb, uuid)', 'visible_class(jsonb)', 'class_change_safe(jsonb, jsonb)',
     'family_conflicts(text[], uuid, boolean)', 'reserved_names()', 'class_acl_admit(text, uuid)', 'class_rows_admit(text, uuid, text[], text)', 'class_has_history(text, uuid)', 'class_orphan_history(text, uuid)', 'class_admit(jsonb, uuid)',
     'trg_entity_bi()', 'trg_entity_bu()', 'trg_entity_ai()', 'trg_entity_au()', 'history_on(text, uuid)', 'signal_token(text, text, bytea)', 'signal_raw(text[])', 'signal(text[], uuid[])', 'class_evolve(@SCHEMA@.entity, @SCHEMA@.entity)',
-    'trg_entity_bd()', 'trg_entity_ad()', 'owner_to_tenant(uuid, uuid)', 'ref_action(jsonb, jsonb, uuid[])', 'delete_preview(uuid[])', 'merge(jsonb, jsonb)', 'inc(jsonb, text[], numeric, numeric)', 'links_patch(jsonb, jsonb)'] loop
+    'trg_entity_bd()', 'trg_entity_bd_account()', 'trg_entity_ad()', 'owner_to_tenant(uuid, uuid)', 'ref_action(jsonb, jsonb, uuid[])', 'delete_preview(uuid[])', 'merge(jsonb, jsonb)', 'inc(jsonb, text[], numeric, numeric)', 'links_patch(jsonb, jsonb)'] loop
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);
     execute format('revoke all on function @SCHEMA@.%s from public', f);
   end loop;

package/sql/80-auth.sql

@@ -795,6 +795,43 @@ begin
     where m.class = 'member' and m.links->>'User' = c.account::text and @SCHEMA@.auth_enabled(m.tenant);
 end $$;
 
+-- Сведения о сессии по токену (db.auth.session): сервис, у которого есть токен пользователя (например, из
+-- cookie), узнаёт, чья это сессия, жива ли она и в каком арендаторе работает, не подключаясь по этому токену.
+-- Право auth.session, как у issue_session. Неверный, погашенный или истёкший токен и отключённый аккаунт — null:
+-- причина не различается, как в ctx(). Сессия ищется только среди SESSION: ключ API или код с тем же sha256 не
+-- подойдут. member — проверка членства из ctx() без исключения: членство в рабочем арендаторе цело и арендатор
+-- включён; собственный арендатор — всегда true.
+create or replace function @SCHEMA@.auth_session_info(p_token text) returns jsonb
+language plpgsql stable security definer
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+declare
+  c record;
+  s record;
+  t uuid;
+begin
+  select * into c from @SCHEMA@.ctx();
+  perform @SCHEMA@.auth_session_required(c.account);
+  perform @SCHEMA@.acl_require('auth.session');
+  select x.account, x.meta, x.expires_at into s from @SCHEMA@.secret x
+  where x.kind = 'SESSION' and x.deleted_at is null and x.material = sha256(convert_to(coalesce(p_token, ''), 'UTF8'))
+    and (x.expires_at is null or x.expires_at > clock_timestamp());
+  if s.account is null or not @SCHEMA@.auth_enabled(s.account) then
+    return null;
+  end if;
+  t := coalesce((s.meta->>'tenant')::uuid, s.account);
+  return jsonb_build_object(
+    'account', s.account,
+    'tenant', t,
+    'member', t = s.account or (
+      exists (select 1 from @SCHEMA@.entity x
+              where x.id = @SCHEMA@.v5_id(t, 'member', array[s.account::text, t::text]) and x.class = 'member' and x.tenant = t)
+      and @SCHEMA@.auth_enabled(t)),
+    'expiresAt', s.expires_at,
+    'loginAt', s.meta->'login_at',
+    'methods', coalesce(s.meta->'methods', '[]'::jsonb));
+end $$;
+
 do $$
 declare f text;
 begin
@@ -807,7 +844,7 @@ begin
     'login_otp(text, text, text)', 'totp_code(bytea, bigint)', 'auth_enroll_totp(uuid)', 'auth_verify_totp(uuid, text, int)',
     'auth_totp_enabled(uuid)', 'auth_link(uuid, text, text, jsonb, boolean)', 'auth_lookup(text, text, boolean)',
     'auth_credentials(uuid)', 'auth_revoke_credential(uuid, boolean)', 'auth_set_flags(uuid, boolean, boolean)',
-    'auth_refresh(interval)', 'auth_logout()', 'auth_logout_all(uuid)', 'auth_switch(uuid)', 'auth_tenants()'] loop
+    'auth_refresh(interval)', 'auth_logout()', 'auth_logout_all(uuid)', 'auth_switch(uuid)', 'auth_tenants()', 'auth_session_info(text)'] loop
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);
     execute format('revoke all on function @SCHEMA@.%s from public', f);
   end loop;
@@ -824,4 +861,4 @@ grant execute on function
   @SCHEMA@.auth_totp_enabled(uuid), @SCHEMA@.auth_link(uuid, text, text, jsonb, boolean), @SCHEMA@.auth_lookup(text, text, boolean),
   @SCHEMA@.auth_credentials(uuid), @SCHEMA@.auth_revoke_credential(uuid, boolean), @SCHEMA@.auth_set_flags(uuid, boolean, boolean),
   @SCHEMA@.auth_refresh(interval), @SCHEMA@.auth_logout(), @SCHEMA@.auth_logout_all(uuid), @SCHEMA@.auth_switch(uuid),
-  @SCHEMA@.auth_tenants() to @APP@;
+  @SCHEMA@.auth_tenants(), @SCHEMA@.auth_session_info(text) to @APP@;

package/sql/88-derived.sql

@@ -143,6 +143,9 @@ begin
     -- как у писателей приложения: разделяемая блокировка семейства, описание — свежее под ней
     perform @SCHEMA@.family_lock(cls, false);
     cls := @SCHEMA@.class_row(cname, tid);
+    if cls.id is null then
+      perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', cname) || w);
+    end if;
     res := cls.data->'resolved';
     if res->>'derivedBy' is distinct from p_name then
       perform @SCHEMA@.lt_fail('derived_class', format('класс %s не производный проектора %s', cname, p_name) || w);
@@ -269,6 +272,7 @@ begin
     from g
     join (select d.class, d.tenant from (select distinct y.class, y.tenant from g y) d
           where @SCHEMA@.history_on(d.class, d.tenant)) h on h.class = g.class and h.tenant = g.tenant
+    order by g.id  -- надгробия в порядке id, как в trg_entity_ad
   )
   select count(*)::int, coalesce(array_agg(distinct g.class || ' ' || g.tenant::text), '{}') into n, pairs from g;
   if n > 0 then
@@ -581,6 +585,82 @@ begin
   end if;
 end $$;
 
+-- Кто описал агрегат p_field цели p_target (строка Class): автор версии строки Class, с которой развёрнутое описание
+-- агрегата (своё или унаследованное) стало нынешним; надгробие обрывает описание — пересоздавший класс описал агрегат
+-- заново. Журнал строк Class не прореживается и не стирается (purge и обрезка их не берут). Сид и пути владельца без
+-- сессии пишут автора System.
+create or replace function @SCHEMA@.agg_author(p_target @SCHEMA@.entity, p_field text) returns uuid
+language sql stable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+return (select l.author from @SCHEMA@.log l
+        where l.id = p_target.id and l.op not in ('purge', 'trim', 'reset', 'delete')
+          and l.data->'resolved'->'aggregate'->p_field is not distinct from p_target.data->'resolved'->'aggregate'->p_field
+          and (select case when p.op = 'delete' then null else p.data->'resolved'->'aggregate'->p_field end
+               from @SCHEMA@.log p
+               where p.id = l.id and p.rev < l.rev and p.op not in ('purge', 'trim', 'reset')
+               order by p.rev desc limit 1) is distinct from p_target.data->'resolved'->'aggregate'->p_field
+        order by l.rev desc limit 1);
+
+-- Аккаунт p_account читает без условий все строки класса p_class арендатора p_tenant: план READ — как у acl_subject
+-- (аккаунт включён и лежит в System, арендатор — сам аккаунт или по членству), но без отказа: нет аккаунта или
+-- членства — права нет.
+create or replace function @SCHEMA@.agg_author_reads(p_account uuid, p_tenant uuid, p_class text) returns boolean
+language plpgsql stable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+declare
+  a jsonb;
+  m jsonb;
+begin
+  select e.data into a from @SCHEMA@.entity e
+  where e.id = p_account and e.class = 'Account' and e.tenant = '@SYSTEM@'::uuid and coalesce((e.data->>'enabled')::boolean, true);
+  if a is null then
+    return false;
+  end if;
+  if p_tenant <> p_account then
+    select x.data into m from @SCHEMA@.entity x
+    where x.id = @SCHEMA@.v5_id(p_tenant, 'member', array[p_account::text, p_tenant::text]) and x.class = 'member' and x.tenant = p_tenant;
+    if m is null then
+      return false;
+    end if;
+  end if;
+  return coalesce(@SCHEMA@.acl_plan_for(p_account, p_tenant,
+      array(select jsonb_array_elements_text(coalesce(a->'categories', '[]'::jsonb))),
+      case when p_tenant = p_account then array['owner']
+           else array(select jsonb_array_elements_text(coalesce(m->'roles', '[]'::jsonb))) end,
+      'READ') -> p_class = '{}'::jsonb, false);
+end $$;
+
+-- Класс p_class арендатора p_tenant становится источником агрегатов — новые метки aggregatedBy описания p_new против
+-- p_old (хвост ревью безопасности доработок после 1.2.0, решение владельца): его строки войдут в агрегат, и описавший
+-- агрегат читал бы в истории цели вклад каждой из них, — поэтому право READ без условий на все строки класса нужно и
+-- описавшему, иначе acl_denied. Объём — тот же, что при описании (class_admit, agg_classes): у агрегата класса
+-- арендатора — классы арендатора, у агрегата класса System — классы System. Класс арендатора под агрегатом System
+-- описавший не проверял и при описании: его, как и прежде, проверяет только тот, кто заводит (agg_source_admit).
+-- Описавший System (сид, путь владельца без сессии) не проверяется.
+create or replace function @SCHEMA@.agg_author_admit(p_class text, p_tenant uuid, p_old jsonb, p_new jsonb) returns void
+language plpgsql stable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+declare
+  mk jsonb;
+  tc @SCHEMA@.entity;
+  who uuid;
+begin
+  for mk in select x from jsonb_array_elements(coalesce(p_new->'aggregatedBy', '[]'::jsonb)) x
+            where not coalesce(p_old->'aggregatedBy', '[]'::jsonb) @> jsonb_build_array(x)
+            order by x->>'class', x->>'field' loop
+    tc := @SCHEMA@.class_row(mk->>'class', p_tenant);
+    continue when tc.id is null or (tc.tenant = '@SYSTEM@'::uuid and p_tenant <> '@SYSTEM@'::uuid);
+    who := @SCHEMA@.agg_author(tc, mk->>'field');
+    continue when who is null or who = '@SYSTEM@'::uuid;
+    if not @SCHEMA@.agg_author_reads(who, tc.tenant, p_class) then
+      perform @SCHEMA@.lt_fail('acl_denied', format('класс %s становится источником агрегата %s.%s, а описавший агрегат не читает все его строки (право READ без условий): агрегат описывает заново тот, кто их читает',
+        p_class, mk->>'class', mk->>'field'));
+    end if;
+  end loop;
+end $$;
+
 -- Метки источников заново: классы арендатора p_tenant (System — всех), в предках которых есть одно из имён p_names;
 -- изменившееся описание — новой версией строки Class (журнал, сигнал).
 create or replace function @SCHEMA@.agg_mark(p_tenant uuid, p_names text[]) returns void
@@ -1142,7 +1222,8 @@ begin
   foreach f in array array['agg_fields(jsonb)', 'agg_of(jsonb)', 'agg_zero(jsonb, jsonb)', 'agg_num(jsonb)', 'agg_where_ok(jsonb, jsonb)',
     'agg_guard(jsonb, jsonb, jsonb, boolean)', 'agg_keep(text, uuid, jsonb, jsonb)', 'agg_check_source(jsonb, jsonb, text, jsonb)',
     'agg_cycle(uuid, jsonb)', 'agg_prepare(jsonb, jsonb, uuid)', 'agg_source(jsonb, uuid)', 'agg_marked(jsonb, jsonb)',
-    'agg_new_mark(jsonb, jsonb)', 'agg_source_admit(text, jsonb)', 'agg_mark(uuid, text[])', 'agg_lock_sources(jsonb, jsonb, uuid)',
+    'agg_new_mark(jsonb, jsonb)', 'agg_source_admit(text, jsonb)', 'agg_author(@SCHEMA@.entity, text)',
+    'agg_author_reads(uuid, uuid, text)', 'agg_author_admit(text, uuid, jsonb, jsonb)', 'agg_mark(uuid, text[])', 'agg_lock_sources(jsonb, jsonb, uuid)',
     'agg_classes(text, uuid, boolean)', 'agg_compute(jsonb, uuid, uuid)',
     'agg_check(text, uuid, jsonb)', 'agg_write(@SCHEMA@.entity, jsonb, boolean)', 'agg_token(text)', 'agg_held()',
     'agg_hold_begin(text)', 'agg_hold_end(boolean)', 'agg_merge(jsonb, jsonb)', 'agg_flush(jsonb)', 'agg_kind(text, uuid)',