letopis 1.2.0 → 1.4.0

package/sql/60-write.sql

@@ -545,6 +545,18 @@ begin
   return jsonb_build_object('rows', vis, 'others', jsonb_array_length(p_rows) - jsonb_array_length(vis));
 end $$;
 
+-- Класс для текста отказа (ревью безопасности №3): наименьший класс среди строк p_rows (строки целиком, to_jsonb), которые
+-- актор видит; не видит ни одной — null, и текст класса не называет. Строки берутся из самих данных, а не из таблицы:
+-- удалённые каскадом в этом же операторе её уже не найдут.
+create or replace function @SCHEMA@.visible_class(p_rows jsonb) returns text
+language sql stable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+return (select min(r->>'class') from jsonb_array_elements(p_rows) r, (select @SCHEMA@.acl_actor('READ') as a) x
+        where x.a is not null
+          and @SCHEMA@.row_visible((r->>'tenant')::uuid, r->>'class', (r->>'id')::uuid, (r->>'owner')::uuid,
+                                   array(select jsonb_array_elements_text(r->'tags')), r->'data', r->'links',
+                                   (x.a->>'tenant')::uuid, (x.a->>'account')::uuid, x.a->'plan'));
+
 -- Безопасно ли изменение описания класса (этап 1, п. 10): новые необязательные поля и концы,
 -- метаданные, алиас, политика истории, кэш. Всё остальное — ужесточение с проверкой строк, в том числе
 -- любая правка условий anyOf и oneOf (1.0.1: прежде они не сравнивались, и строки не перепроверялись),
@@ -585,6 +597,7 @@ declare
   outv jsonb := '[]'::jsonb;
   a jsonb := @SCHEMA@.acl_actor('READ');
   vis boolean;
+  ref jsonb;
 begin
   for r in select e.* from @SCHEMA@.entity e
            where e.class = any (p_classes) and (e.tenant = p_tenant or p_tenant = '@SYSTEM@'::uuid)
@@ -610,13 +623,17 @@ begin
     if problem is null and p_incoming then
       inc := @SCHEMA@.incoming_conflicts(r.id, r.class, r.tenant);
       if inc <> '[]'::jsonb then
-        -- id ссылающейся строки — только если актор её видит (доработки после точки Б)
-        select @SCHEMA@.row_visible(x.tenant, x.class, x.id, x.owner, x.tags, x.data, x.links,
-                                    (a->>'tenant')::uuid, (a->>'account')::uuid, a->'plan') into vis
-        from @SCHEMA@.entity x where x.id = (inc->0->>'id')::uuid;
-        problem := case when coalesce(vis, false)
-          then format('на строку ссылается роль %s строки %s, которая не принимает класс', inc->0->>'role', inc->0->>'id')
-          else format('на строку ссылается роль %s строки, которой актор не видит, и она не принимает класс', inc->0->>'role') end;
+        -- роль и id ссылающейся строки — только если актор её видит (доработки после точки Б; ревью безопасности №3:
+        -- о невидимой — ни роли, ни id); видимые ссылающиеся строки — первыми, затем по id
+        select i.v, coalesce(@SCHEMA@.row_visible(x.tenant, x.class, x.id, x.owner, x.tags, x.data, x.links,
+                                                  (a->>'tenant')::uuid, (a->>'account')::uuid, a->'plan'), false) as seen
+          into ref, vis
+        from jsonb_array_elements(inc) i(v)
+        left join @SCHEMA@.entity x on x.id = (i.v->>'id')::uuid
+        order by seen desc, i.v->>'id' limit 1;
+        problem := case when vis
+          then format('на строку ссылается роль %s строки %s, которая не принимает класс', ref->>'role', ref->>'id')
+          else 'на строку ссылается строка, которой актор не видит, и она не принимает класс' end;
       end if;
     end if;
     if problem is not null then
@@ -678,14 +695,38 @@ begin
   end loop;
 end $$;
 
--- Есть ли в журнале версии строк класса p_name арендатора p_tenant (у класса System — любого арендатора); записи purge,
--- trim и reset — не версии (доработки после точки Б: удаление и пересоздание класса, остаток Н2 ревью №2).
+-- Есть ли в журнале версии строк класса p_name арендатора p_tenant; записи purge, trim и reset — не версии (доработки
+-- после точки Б: удаление и пересоздание класса, остаток Н2 ревью №2). У класса System — строки любого арендатора, кроме
+-- арендаторов со своим классом с тем же именем: их строки — строки своего класса, как их резолвит class_row (ревью
+-- безопасности №3: история такого класса не мешает администратору создать и удалить класс System)
 create or replace function @SCHEMA@.class_has_history(p_name text, p_tenant uuid) returns boolean
 language sql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 return exists (select 1 from @SCHEMA@.log l
-               where l.class = p_name and (l.tenant = p_tenant or p_tenant = '@SYSTEM@'::uuid)
-                 and l.op not in ('purge', 'trim', 'reset'));
+               where l.class = p_name and l.op not in ('purge', 'trim', 'reset')
+                 and (l.tenant = p_tenant
+                      or p_tenant = '@SYSTEM@'::uuid
+                         and l.tenant <> all (array(select x.tenant from @SCHEMA@.entity x
+                                                    where x.class = 'Class' and x.data->>'name' = p_name
+                                                      and x.tenant <> '@SYSTEM@'::uuid))));
+
+-- Хранят ли историю строк удалённые потомки класса p_name: надгробия строк Class (последняя версия их id — удаление),
+-- у которых в resolved.ancestors есть p_name (ревью безопасности №3). Правила находят старые версии строк и по алиасам
+-- предков, а надгробие потомка их не записывает: пока такая история есть, предок не меняет алиас ни правкой, ни
+-- удалением и созданием заново. У класса System — кроме арендаторов со своим одноимённым классом, как class_has_history
+create or replace function @SCHEMA@.class_orphan_history(p_name text, p_tenant uuid) returns boolean
+language sql stable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+return exists (select 1 from @SCHEMA@.log t
+               where t.class = 'Class' and t.op = 'delete' and t.data->>'name' <> p_name
+                 and t.data->'resolved'->'ancestors' ? p_name
+                 and (t.tenant = p_tenant
+                      or p_tenant = '@SYSTEM@'::uuid
+                         and t.tenant <> all (array(select x.tenant from @SCHEMA@.entity x
+                                                    where x.class = 'Class' and x.data->>'name' = p_name
+                                                      and x.tenant <> '@SYSTEM@'::uuid)))
+                 and not exists (select 1 from @SCHEMA@.log z where z.id = t.id and z.rev > t.rev)
+                 and @SCHEMA@.class_has_history(t.data->>'name', t.tenant));
 
 -- Проверки строки Class сверх метасхемы (этап 1, п. 6): признак system, имя системного класса,
 -- имена связей против методов цепочки, однозначность имени конца во всей схеме, право на агрегаты,
@@ -705,6 +746,7 @@ declare
   src text;
   chk jsonb;
   m jsonb;
+  dkid text;
 begin
   if p_tenant <> '@SYSTEM@'::uuid then
     if (p_data->>'name') = any (array['Class', 'Account', 'member', 'Resource', 'rule']) then
@@ -718,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'));
@@ -755,6 +805,23 @@ begin
     perform @SCHEMA@.lt_fail('acl_denied', format('класс %s производный: его описание задаёт только администратор (право letopis.projector)',
       data->>'name'));
   end if;
+  -- предок производного класса (ревью безопасности №3): правка предка пересчитывает описание потомка (class_evolve) —
+  -- поля, ключ, 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 <> 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
+      perform @SCHEMA@.lt_fail('acl_denied', format('класс %s — предок производного класса %s: его описание задаёт только администратор (право letopis.projector)',
+        data->>'name', dkid));
+    end if;
+  end if;
   -- агрегат развёрнутого описания (свой или унаследованный), новый или изменённый против прежнего — описание
   -- агрегата, новый потомок цели, смена parent, — задаёт только тот, кто без условий читает все строки каждого
   -- класса-источника: класса of и его потомков (agg_classes: классы арендатора, у класса System — классы System).
@@ -762,6 +829,13 @@ begin
   if data->'resolved' ? 'aggregate' then
     for e in select key, value from jsonb_each(data->'resolved'->'aggregate') order by key loop
       continue when prevd->'resolved'->'aggregate'->e.key is not distinct from e.value;
+      -- класс-источник должен уже быть (ревью безопасности №3, /security-review): пока его нет, проверять право READ не
+      -- на чем, а когда класс заведёт другой пользователь, проверялись бы только его права — и описавший агрегат читал бы
+      -- в истории цели вклад каждой строки источника. Поэтому источник описывают раньше агрегата
+      if cardinality(@SCHEMA@.agg_classes(e.value->>'of', p_tenant, p_tenant = '@SYSTEM@'::uuid)) = 0 then
+        perform @SCHEMA@.lt_fail('invalid_class', format('агрегат %s.%s: класса-источника %s и его потомков %s нет — источник описывают раньше агрегата',
+          data->>'name', e.key, e.value->>'of', case when p_tenant = '@SYSTEM@'::uuid then 'в System' else 'у арендатора' end));
+      end if;
       -- сам класс of первым, потомки — по имени
       foreach src in array array(select n from unnest(@SCHEMA@.agg_classes(e.value->>'of', p_tenant, p_tenant = '@SYSTEM@'::uuid)) n
                                  order by n = (e.value->>'of') desc, n) loop
@@ -793,6 +867,13 @@ begin
           or prevd->'resolved'->'derivedBy' is distinct from data->'resolved'->'derivedBy') then
     perform @SCHEMA@.class_acl_admit(data->>'name', p_tenant);
   end if;
+  -- алиас класса, у которого удалённые потомки хранят историю строк (ревью безопасности №3): правила находят их старые
+  -- версии и по алиасам предков, а надгробие потомка их не записывает — алиас меняется после purge() их строк
+  if prevd is not null and prevd->>'alias' is distinct from data->>'alias'
+     and @SCHEMA@.class_orphan_history(data->>'name', p_tenant) then
+    perform @SCHEMA@.lt_fail('invalid_class', format('удалённые потомки класса %s хранят историю строк: алиас меняется после purge() их строк',
+      data->>'name'));
+  end if;
   -- политика хранения истории (доработки после точки Б): по ней maintain() прореживает журнал строк класса, а
   -- history: false выключает журнал. Одним правом WRITE на Class автор правки стирал бы аудит строк, на которые у него
   -- нет прав, поэтому смена развёрнутой history существующего класса требует права READ и DELETE без условий на все
@@ -892,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));
@@ -951,12 +1035,17 @@ begin
   -- старую историю под чужие правила. Поэтому, если журнал арендатора хранит версии строк класса с этим именем, класс
   -- создаётся только заново и с тем же описанием, что в надгробии его строки Class. Надгробия нет (история осталась от
   -- класса System, удалённого раньше, или строку Class стёрли мимо триггеров) — отказ: сначала purge() строк
-  if NEW.class = 'Class' and @SCHEMA@.class_has_history(NEW.data->>'name', NEW.tenant)
+  -- Так же — если историю хранят удалённые потомки класса (их правила находят старые версии и по алиасу предка), и
+  -- политика хранения прежняя: по ней maintain() прореживает старые версии (ревью безопасности №3; у описаний без ключа
+  -- history в resolved — значение по умолчанию true)
+  if NEW.class = 'Class'
+     and (@SCHEMA@.class_has_history(NEW.data->>'name', NEW.tenant) or @SCHEMA@.class_orphan_history(NEW.data->>'name', NEW.tenant))
      and not (coalesce(last.op = 'delete', false)
               and last.data->'resolved'->'ancestors' is not distinct from NEW.data->'resolved'->'ancestors'
               and last.data->>'alias' is not distinct from NEW.data->>'alias'
-              and last.data->'resolved'->'derivedBy' is not distinct from NEW.data->'resolved'->'derivedBy') then
-    perform @SCHEMA@.lt_fail('invalid_class', format('журнал хранит историю строк класса %s: создать его можно только заново и с прежними parent, alias и derivedBy (или сначала стереть её purge())',
+              and last.data->'resolved'->'derivedBy' is not distinct from NEW.data->'resolved'->'derivedBy'
+              and coalesce(last.data->'resolved'->'history', 'true'::jsonb) is not distinct from coalesce(NEW.data->'resolved'->'history', 'true'::jsonb)) then
+    perform @SCHEMA@.lt_fail('invalid_class', format('журнал хранит историю строк класса %s или его удалённых потомков: создать его можно только заново и с прежними parent, alias, derivedBy и history (или сначала стереть её purge())',
       NEW.data->>'name'));
   end if;
   ts := @SCHEMA@.now_ts();
@@ -1016,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));
@@ -1137,6 +1229,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';
@@ -1194,6 +1290,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), каждая — сигнал кэшу
@@ -1241,6 +1338,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 +1460,9 @@ declare
   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 — на строку,
@@ -1376,14 +1478,42 @@ 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
       perform @SCHEMA@.lt_fail('acl_denied', format('класс %s производный: его описание задаёт только администратор (право letopis.projector)', r.name));
     end if;
-    if exists (select 1 from @SCHEMA@.entity x where x.class = r.name and (x.tenant = r.tenant or r.tenant = '@SYSTEM@'::uuid))
+    -- класс-источник агрегата (автоматическое ревью коммита 5290be1): пока его называет агрегат класса того же
+    -- арендатора, класс не удаляется — иначе класс с этим именем завёл бы потом другой пользователь, и право READ
+    -- описавшего агрегат на его строки уже не проверить (класс of проверяется только при описании агрегата). Агрегаты
+    -- классов System описывает системный администратор: он читает всё
+    if r.tenant <> '@SYSTEM@'::uuid then
+      select x.data->>'name' || '.' || a.key into denied
+      from @SCHEMA@.entity x cross join lateral jsonb_each(x.data->'resolved'->'aggregate') a
+      where x.class = 'Class' and x.tenant = r.tenant and x.data->'resolved' ? 'aggregate' and a.value->>'of' = r.name
+      order by 1 limit 1;
+      if denied is not null then
+        perform @SCHEMA@.lt_fail('invalid_class', format('класс %s — источник агрегата %s: сначала уберите агрегат из описания цели',
+          r.name, denied));
+      end if;
+    end if;
+    -- у класса System — строки и потомки любого арендатора, кроме арендаторов со своим одноимённым классом: их строки и
+    -- потомки относятся к своему классу (class_row; ревью безопасности №3)
+    own := case when r.tenant = '@SYSTEM@'::uuid
+                then array(select x.tenant from @SCHEMA@.entity x
+                           where x.class = 'Class' and x.data->>'name' = r.name and x.tenant <> '@SYSTEM@'::uuid)
+                else '{}'::uuid[] end;
+    if exists (select 1 from @SCHEMA@.entity x
+               where x.class = r.name and (x.tenant = r.tenant or r.tenant = '@SYSTEM@'::uuid and x.tenant <> all (own)))
        or exists (select 1 from @SCHEMA@.entity x where x.class = 'Class' and x.data->>'parent' = r.name
-                  and (x.tenant = r.tenant or r.tenant = '@SYSTEM@'::uuid)) then
+                  and (x.tenant = r.tenant or r.tenant = '@SYSTEM@'::uuid and x.tenant <> all (own))) then
       perform @SCHEMA@.lt_fail('invalid_class', format('у класса %s есть строки или потомки', r.name));
     end if;
     -- и история строк (остаток Н2; доработки после точки Б): удалённый класс с историей, созданный заново с другими
@@ -1439,12 +1569,15 @@ begin
     )
     select coalesce(array_agg(d.id), '{}'), coalesce(array_agg(distinct d.class), '{}'),
            coalesce(array_agg(distinct d.class || ' ' || d.tenant::text), '{}'),
-           min(d.class) filter (where not @SCHEMA@.acl_row_ok(dplan, d.class, d.id, d.owner, d.tenant, d.tags, d.data, d.links)),
+           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, denied, lvl_accs, lvl_mems from d;
-    if denied is not null then
-      perform @SCHEMA@.lt_fail('acl_denied', format('нет права DELETE на класс %s в каскаде удаления', denied));
+      into lvl, lvl_classes, lvl_pairs, drows, lvl_accs, 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;
@@ -1453,7 +1586,9 @@ begin
     -- unset: снять конец, новая версия
     for r in select x.* from @SCHEMA@.entity x where x.id = any (unsets) order by x.id for update loop
       if not @SCHEMA@.acl_row_ok(wplan, r.class, r.id, r.owner, r.tenant, r.tags, r.data, r.links) then
-        perform @SCHEMA@.lt_fail('acl_denied', format('нет права WRITE на класс %s: снятие конца при удалении', r.class));
+        perform @SCHEMA@.lt_fail('acl_denied', case when @SCHEMA@.visible_class(jsonb_build_array(to_jsonb(r))) is not null
+                                                     then format('нет права WRITE на класс %s: снятие конца при удалении', r.class)
+                                                     else 'нет права WRITE на ссылающуюся строку: снятие конца при удалении' end);
       end if;
       newlinks := '{}'::jsonb;
       for k in select key, value from jsonb_each(r.links) loop
@@ -1627,7 +1762,10 @@ begin
     -- строки производного класса пишет только проектор: перевод их ссылок мимо него оставил бы проекцию
     -- несогласованной (ревью безопасности №3, №3)
     if (@SCHEMA@.class_row(r.class, r.tenant)).data->'resolved' ? 'derivedBy' then
-      perform @SCHEMA@.lt_fail('derived_class', format('на строку ссылается строка производного класса %s: её пишет проектор', r.class));
+      perform @SCHEMA@.lt_fail('derived_class',
+        case when p_plan is null or @SCHEMA@.visible_class(jsonb_build_array(to_jsonb(r))) is not null
+             then format('на строку ссылается строка производного класса %s: её пишет проектор', r.class)
+             else 'на строку ссылается строка производного класса: её пишет проектор' end);
     end if;
     if p_plan is not null and not @SCHEMA@.acl_row_ok(p_plan, r.class, r.id, r.owner, r.tenant, r.tags, r.data, r.links) then
       perform @SCHEMA@.lt_fail('acl_denied', 'нет права WRITE на ссылающиеся строки');
@@ -1702,6 +1840,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));
@@ -1886,8 +2027,8 @@ begin
     'apply_defaults(jsonb, jsonb)', 'links_shape(jsonb, jsonb)', 'targets_bad(jsonb, boolean, jsonb)', 'check_links(jsonb, jsonb, uuid, boolean, jsonb)', 'key_id(jsonb, text, uuid, jsonb, jsonb)',
     'log_version(@SCHEMA@.entity)', 'sys_update(uuid, jsonb, jsonb, jsonpath, text, text)', 'tombstone(@SCHEMA@.entity, text, uuid)',
     'links_replace(jsonb, uuid, uuid)', 'move_row(@SCHEMA@.entity, uuid, text, jsonb, jsonb, text, jsonb)', 'reclass(uuid, text, jsonb)',
-    'incoming_conflicts(uuid, text, uuid)', 'visible_detail(jsonb, uuid)', '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_admit(jsonb, uuid)',
+    '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
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);

package/sql/88-derived.sql

@@ -5,8 +5,8 @@
 -- читает журнал всех арендаторов функцией watch_read и пишет строки производных классов (derivedBy)
 -- только функцией derived_apply. Чекпоинт — строка secret вида PROJECTOR (account = System, ident —
 -- имя проектора): курсор журнала со снимком, версия проектора, состояние, выбывшие арендаторы. Курсор
--- сдвигается в той же транзакции, что и запись результатов; писатель один — транзакционная
--- advisory-блокировка (19542, «схема:имя») на каждую пачку. Функции кредов вид PROJECTOR не видят
+-- сдвигается в той же транзакции, что и запись результатов; писатель один — строка-замок secret вида LOCK
+-- («схема:projector:имя», lock_try в 60-write.sql) на каждую пачку. Функции кредов вид PROJECTOR не видят
 -- (80-auth.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);
@@ -581,6 +584,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 +1221,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)',