letopis 1.4.2 → 3.0.0

package/sql/30-validate.sql

@@ -41,7 +41,8 @@ return to_jsonb(s)::text;
 -- Перевод шаблона JavaScript в регулярное выражение PostgreSQL (этап 1, п. 5): разбор по символам,
 -- как translatePattern в lib/src/jsonschema.ts. \d \w \s и их отрицания — явными наборами (внутри
 -- [ ] — без скобок), экранированная обратная косая черта остаётся собой; \b, \p{…}, именованные
--- группы и обратные ссылки отклоняются.
+-- группы и обратные ссылки отклоняются. Отказы здесь и в jp_compile — lt_fail(…, p_detail => 'null'): DETAIL у них
+-- не было и до каталога (raise без detail), у ошибки библиотеки detail нет (15-errors.sql).
 create or replace function @SCHEMA@.jp_pattern(p text) returns text
 language plpgsql immutable strict
 as $$
@@ -52,7 +53,6 @@ declare
   n text;
   in_class boolean := false;
   sp constant text := ' \t\n\r\f\v';
-  why text;
 begin
   while i <= length(p) loop
     c := substr(p, i, 1);
@@ -60,7 +60,7 @@ begin
       n := substr(p, i + 1, 1);
       i := i + 2;
       if n = '' then
-        why := 'обратная косая черта в конце шаблона';
+        perform @SCHEMA@.lt_fail('sql-core.pattern_trailing_backslash', jsonb_build_object('pattern', p), p_detail => 'null');
       elsif n = 'd' then
         res := res || case when in_class then '0-9' else '[0-9]' end;
       elsif n = 'w' then
@@ -69,26 +69,23 @@ begin
         res := res || case when in_class then sp else '[' || sp || ']' end;
       elsif n in ('D', 'W', 'S') then
         if in_class then
-          why := '\' || n || ' внутри набора [ ] не переводится';
+          perform @SCHEMA@.lt_fail('sql-core.pattern_escape_in_set', jsonb_build_object('pattern', p, 'escape', '\' || n), p_detail => 'null');
         else
           res := res || case n when 'D' then '[^0-9]' when 'W' then '[^A-Za-z0-9_]' else '[^' || sp || ']' end;
         end if;
       elsif n in ('b', 'B') then
-        why := '\' || n || ' в PostgreSQL значит другое';
+        perform @SCHEMA@.lt_fail('sql-core.pattern_word_boundary', jsonb_build_object('pattern', p, 'escape', '\' || n), p_detail => 'null');
       elsif n in ('p', 'P') then
-        why := '\p{…} не поддерживается';
+        perform @SCHEMA@.lt_fail('sql-core.pattern_unicode_property', jsonb_build_object('pattern', p), p_detail => 'null');
       elsif n = 'k' or n ~ '[1-9]' then
-        why := 'обратные ссылки не поддерживаются';
+        perform @SCHEMA@.lt_fail('sql-core.pattern_backreference', jsonb_build_object('pattern', p), p_detail => 'null');
       else
         res := res || c || n;
       end if;
-      if why is not null then
-        raise exception using errcode = 'LT010', message = 'letopis: invalid_class: шаблон ' || p || ' несовместим с регулярными выражениями PostgreSQL (' || why || ')';
-      end if;
       continue;
     end if;
     if not in_class and substr(p, i, 3) = '(?<' and substr(p, i + 3, 1) not in ('=', '!') then
-      raise exception using errcode = 'LT010', message = 'letopis: invalid_class: шаблон ' || p || ' несовместим с регулярными выражениями PostgreSQL (именованные группы не поддерживаются)';
+      perform @SCHEMA@.lt_fail('sql-core.pattern_named_group', jsonb_build_object('pattern', p), p_detail => 'null');
     end if;
     if c = '[' and not in_class then
       in_class := true;
@@ -153,11 +150,11 @@ begin
     rules := r; return;
   end if;
   if jsonb_typeof(p_schema) <> 'object' then
-    raise exception using errcode = 'LT010', message = format('letopis: invalid_class: описание узла %s — не объект', p_disp);
+    perform @SCHEMA@.lt_fail('sql-core.schema_node_not_object', jsonb_build_object('node', p_disp::text), p_detail => 'null');
   end if;
   for k in select jsonb_object_keys(p_schema) loop
     if not (k = any (allowed) or k like 'x-%') then
-      raise exception using errcode = 'LT010', message = format('letopis: invalid_class: ключевое слово %s не поддерживается (узел %s)', k, p_disp);
+      perform @SCHEMA@.lt_fail('sql-core.keyword_unsupported', jsonb_build_object('keyword', k, 'node', p_disp::text), p_detail => 'null');
     end if;
   end loop;
 
@@ -170,7 +167,7 @@ begin
       tcond := @SCHEMA@.jp_type_cond(p_schema->>'type');
     end if;
     if tcond is null then
-      raise exception using errcode = 'LT010', message = format('letopis: invalid_class: неизвестный тип в узле %s', p_disp);
+      perform @SCHEMA@.lt_fail('sql-core.unknown_type', jsonb_build_object('node', p_disp::text), p_detail => 'null');
     end if;
     r := r || jsonb_build_object('path', p_disp, 'keyword', 'type', 'path_expr', p_path, 'cond', tcond, 'vars', '{}'::jsonb);
   end if;
@@ -181,7 +178,7 @@ begin
     for v in select x from jsonb_array_elements(coalesce(p_schema->'enum', jsonb_build_array(p_schema->'const'))) x loop
       if jsonb_typeof(v) in ('object', 'array') then
         if p_in_any then
-          raise exception using errcode = 'LT010', message = format('letopis: invalid_class: перечисление объектов внутри anyOf не поддерживается (узел %s)', p_disp);
+          perform @SCHEMA@.lt_fail('sql-core.enum_objects_in_any_of', jsonb_build_object('node', p_disp::text), p_detail => 'null');
         end if;
         r := r || jsonb_build_object('path', p_disp, 'keyword', case when p_schema ? 'enum' then 'enum' else 'const' end,
           'path_expr', p_path, 'cond', 'true', 'vars', '{}'::jsonb, 'extra', jsonb_build_object('kind', 'enum', 'values', coalesce(p_schema->'enum', jsonb_build_array(p_schema->'const'))));
@@ -227,11 +224,11 @@ begin
         when 'email' then '^[^@[:space:]]+@[^@[:space:]]+\.[^@[:space:]]+$'
         else null end) || ')');
     if t not in ('uuid', 'date', 'date-time', 'email') then
-      raise exception using errcode = 'LT010', message = format('letopis: invalid_class: format %s не поддерживается (узел %s)', t, p_disp);
+      perform @SCHEMA@.lt_fail('sql-core.format_unsupported', jsonb_build_object('format', t, 'node', p_disp::text), p_detail => 'null');
     end if;
     if t in ('date', 'date-time') then
       if p_in_any then
-        raise exception using errcode = 'LT010', message = format('letopis: invalid_class: format %s внутри anyOf не поддерживается (узел %s)', t, p_disp);
+        perform @SCHEMA@.lt_fail('sql-core.format_in_any_of', jsonb_build_object('format', t, 'node', p_disp::text), p_detail => 'null');
       end if;
       r := r || jsonb_build_object('path', p_disp, 'keyword', 'format', 'path_expr', p_path, 'cond', 'true', 'vars', '{}'::jsonb,
         'extra', jsonb_build_object('kind', 'date', 'type', case t when 'date' then 'date' else 'timestamptz' end,
@@ -241,7 +238,7 @@ begin
   end if;
   if p_schema ? 'minLength' or p_schema ? 'maxLength' then
     if p_in_any then
-      raise exception using errcode = 'LT010', message = format('letopis: invalid_class: длина строки внутри anyOf не поддерживается (узел %s)', p_disp);
+      perform @SCHEMA@.lt_fail('sql-core.string_length_in_any_of', jsonb_build_object('node', p_disp::text), p_detail => 'null');
     end if;
     r := r || jsonb_build_object('path', p_disp, 'keyword', case when p_schema ? 'minLength' then 'minLength' else 'maxLength' end,
       'path_expr', p_path, 'cond', 'true', 'vars', '{}'::jsonb,
@@ -258,7 +255,7 @@ begin
   end loop;
   if coalesce((p_schema->>'uniqueItems')::boolean, false) then
     if p_in_any then
-      raise exception using errcode = 'LT010', message = format('letopis: invalid_class: uniqueItems внутри anyOf не поддерживается (узел %s)', p_disp);
+      perform @SCHEMA@.lt_fail('sql-core.unique_items_in_any_of', jsonb_build_object('node', p_disp::text), p_detail => 'null');
     end if;
     r := r || jsonb_build_object('path', p_disp, 'keyword', 'uniqueItems', 'path_expr', p_path, 'cond', 'true', 'vars', '{}'::jsonb,
       'extra', jsonb_build_object('kind', 'unique'));
@@ -277,7 +274,7 @@ begin
   end if;
   if p_schema ? 'minProperties' or p_schema ? 'maxProperties' then
     if p_in_any then
-      raise exception using errcode = 'LT010', message = format('letopis: invalid_class: minProperties внутри anyOf не поддерживается (узел %s)', p_disp);
+      perform @SCHEMA@.lt_fail('sql-core.min_properties_in_any_of', jsonb_build_object('node', p_disp::text), p_detail => 'null');
     end if;
     r := r || jsonb_build_object('path', p_disp, 'keyword', case when p_schema ? 'minProperties' then 'minProperties' else 'maxProperties' end,
       'path_expr', p_path, 'cond', 'true', 'vars', '{}'::jsonb,
@@ -354,8 +351,18 @@ begin
   validator := ('strict ' || expr)::jsonpath;
 end $$;
 
+-- Допустимые значения перечисления для сообщения нарушения (план 2.1, A8): JSON через запятую, первые 20 — как у
+-- валидатора на TypeScript (validate.ts, enumValues).
+create or replace function @SCHEMA@.issue_values(p_values jsonb) returns text
+language sql immutable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+return (select string_agg(t.y::text, ', ' order by t.o) || case when jsonb_array_length(p_values) > 20 then ', …' else '' end
+        from jsonb_array_elements(p_values) with ordinality t(y, o) where t.o <= 20);
+
 -- Проверка данных: общий вызов jsonb_path_match; при отказе — список нарушений по правилам.
 -- Результат сравнивается через is true: ошибка внутри выражения даёт NULL, а не «да» (этап 1, п. 5).
+-- Нарушение — { path, keyword, message, key, params }: message — русский текст по ключу каталога, рядом его key и
+-- params; библиотека убирает key и params (fromDbError, загрузчик).
 create or replace function @SCHEMA@.validate_data(p_rules jsonb, p_validator jsonpath, p_vars jsonb, p_data jsonb) returns jsonb
 language plpgsql stable
 as $$
@@ -364,6 +371,8 @@ declare
   bad jsonb := '[]'::jsonb;
   ok boolean;
   x jsonb;
+  p jsonb;
+  t text;
 begin
   ok := jsonb_path_match(p_data, p_validator, p_vars, true) is true;
   if ok and not exists (select 1 from jsonb_array_elements(p_rules) r where r ? 'extra') then
@@ -373,38 +382,78 @@ begin
     if e ? 'extra' then
       for x in select * from jsonb_path_query(p_data, ('strict ' || (e->>'path_expr'))::jsonpath, '{}'::jsonb, true) loop
         if (e->'extra'->>'kind') = 'length' and jsonb_typeof(x) = 'string' then
-          if char_length(x #>> '{}') < coalesce((e->'extra'->>'min')::int, 0)
-             or char_length(x #>> '{}') > coalesce((e->'extra'->>'max')::int, 2147483647) then
-            bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', 'длина строки вне границ');
+          -- текст называет границу (letopis 2.1, второй раунд, A6) — как у валидатора на TypeScript (validate.ts)
+          t := null;
+          if char_length(x #>> '{}') < coalesce((e->'extra'->>'min')::int, 0) then
+            t := 'sql-core.issue_string_too_short';
+            p := jsonb_build_object('limit', (e->'extra'->>'min')::int);
+          elsif char_length(x #>> '{}') > coalesce((e->'extra'->>'max')::int, 2147483647) then
+            t := 'sql-core.issue_string_too_long';
+            p := jsonb_build_object('limit', (e->'extra'->>'max')::int);
+          end if;
+          if t is not null then
+            bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', @SCHEMA@.lt_text(t, p),
+              'key', t, 'params', p);
           end if;
         elsif (e->'extra'->>'kind') = 'unique' and jsonb_typeof(x) = 'array' then
           if (select count(*) from jsonb_array_elements(x)) <> (select count(distinct y) from jsonb_array_elements(x) y) then
-            bad := bad || jsonb_build_object('path', e->'path', 'keyword', 'uniqueItems', 'message', 'элементы повторяются');
+            bad := bad || jsonb_build_object('path', e->'path', 'keyword', 'uniqueItems', 'message', @SCHEMA@.lt_text('sql-core.issue_unique_items'),
+              'key', 'sql-core.issue_unique_items', 'params', '{}'::jsonb);
           end if;
         elsif (e->'extra'->>'kind') = 'date' and jsonb_typeof(x) = 'string' then
           -- смысл проверяется только у строки правильной формы: форму проверяет правило format
           if (x #>> '{}') ~ (e->'extra'->>'re') and not pg_input_is_valid(x #>> '{}', e->'extra'->>'type') then
-            bad := bad || jsonb_build_object('path', e->'path', 'keyword', 'format', 'message', 'такой даты не бывает');
+            bad := bad || jsonb_build_object('path', e->'path', 'keyword', 'format', 'message', @SCHEMA@.lt_text('sql-core.issue_date'),
+              'key', 'sql-core.issue_date', 'params', '{}'::jsonb);
           end if;
         elsif (e->'extra'->>'kind') = 'props' and jsonb_typeof(x) = 'object' then
           if (select count(*) from jsonb_object_keys(x)) < coalesce((e->'extra'->>'min')::int, 0)
              or (select count(*) from jsonb_object_keys(x)) > coalesce((e->'extra'->>'max')::int, 2147483647) then
-            bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', 'число ключей вне границ');
+            bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', @SCHEMA@.lt_text('sql-core.issue_property_count'),
+              'key', 'sql-core.issue_property_count', 'params', '{}'::jsonb);
           end if;
         elsif (e->'extra'->>'kind') = 'enum' then
           if not exists (select 1 from jsonb_array_elements(e->'extra'->'values') y where y = x) then
-            bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', 'значение не из перечисления');
+            p := jsonb_build_object('values', @SCHEMA@.issue_values(e->'extra'->'values'));
+            bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', @SCHEMA@.lt_text('sql-core.issue_enum', p),
+              'key', 'sql-core.issue_enum', 'params', p);
           end if;
         end if;
       end loop;
     elsif not ok then
       if jsonb_path_match(p_data, ('strict !exists(' || (e->>'path_expr') || ' ? (!(' || (e->>'cond') || ')))')::jsonpath, e->'vars', true) is not true then
-        bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', 'нарушено правило ' || (e->>'keyword'));
+        t := null;
+        if e->>'keyword' in ('enum', 'const') then
+          -- перечисление скаляров: значения — переменные правила v<N> (план 2.1, A8)
+          p := jsonb_build_object('values', @SCHEMA@.issue_values(
+            coalesce((select jsonb_agg(v.value order by (substr(v.key, 2))::int) from jsonb_each(e->'vars') v), '[]'::jsonb)));
+          bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', @SCHEMA@.lt_text('sql-core.issue_enum', p),
+            'key', 'sql-core.issue_enum', 'params', p);
+          continue;
+        elsif e->>'keyword' = 'additionalProperties' then
+          -- лишние ключи: ключ, которого условие правила не принимает и в одиночку (план 2.1, A8)
+          select string_agg(z.k, ', ' order by z.k) into t from (
+            select distinct kv.key as k
+            from jsonb_path_query(p_data, ('strict ' || (e->>'path_expr'))::jsonpath, '{}'::jsonb, true) n(v)
+            cross join lateral jsonb_each(case when jsonb_typeof(n.v) = 'object' then n.v else '{}'::jsonb end) kv
+            where jsonb_path_exists(jsonb_build_object(kv.key, null), ('strict $ ? (' || (e->>'cond') || ')')::jsonpath, e->'vars', true) is not true
+            order by 1 limit 20) z;
+        end if;
+        if t is not null then
+          p := jsonb_build_object('keys', t);
+          bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', @SCHEMA@.lt_text('sql-core.issue_additional', p),
+            'key', 'sql-core.issue_additional', 'params', p);
+        else
+          p := jsonb_build_object('keyword', e->>'keyword');
+          bad := bad || jsonb_build_object('path', e->'path', 'keyword', e->>'keyword', 'message', @SCHEMA@.lt_text('sql-core.issue_rule', p),
+            'key', 'sql-core.issue_rule', 'params', p);
+        end if;
       end if;
     end if;
   end loop;
   if not ok and bad = '[]'::jsonb then
-    bad := jsonb_build_array(jsonb_build_object('path', '[]'::jsonb, 'keyword', 'schema', 'message', 'данные не проходят описание'));
+    bad := jsonb_build_array(jsonb_build_object('path', '[]'::jsonb, 'keyword', 'schema', 'message', @SCHEMA@.lt_text('sql-core.issue_schema'),
+      'key', 'sql-core.issue_schema', 'params', '{}'::jsonb));
   end if;
   return bad;
 end $$;
@@ -415,7 +464,7 @@ begin
   foreach f in array array[
     'uuid_v5(uuid, text)', 'v5_name(text, text[])', 'v5_id(uuid, text, text[])', 'jp_str(text)', 'jp_pattern(text)',
     'jp_type_cond(text)', 'jp_prop(text, text)', 'jp_items(text)', 'jp_compile(jsonb, text, jsonb, boolean, int)', 'compile_validator(jsonb)',
-    'validate_data(jsonb, jsonpath, jsonb, jsonb)'] loop
+    'issue_values(jsonb)', 'validate_data(jsonb, jsonpath, 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/40-class.sql

@@ -10,14 +10,9 @@
 --             нескольким полям (anyOf, oneOf) потомок заменяет целиком, как поле
 --   ends      { <роль>: { class: <класс> | [<класс>…], many, required, min, max, onDelete, meta } }
 --   key       [<поле или роль>…] — из них вычисляется id (§2.3); [] — класс без ключа
---   history   true | false | политика хранения (§2.11)
+--   history   true | false — вести ли журнал версий
 --   ownerDefault 'tenant' | 'actor';  cache { ttl };  meta {…} до 64 КБ
---   derivedBy имя проектора (план 1.1, §2.4): строки класса пишет только он; наследуется, потомок не меняет
---   aggregate { <поле>: { sum: <поле источника> | count: true, of: <класс-источник>, via: <роль>, where?: JSON Schema } }
---             агрегаты в базе (план 1.1, §2.4): поле держит триггер по живым строкам источника; наследуется,
---             потомок заменяет целиком
---   resolved  развёрнутое описание с учётом предков — пишет триггер, присланное значение перезаписывается; у
---             источника агрегатов в нём ещё метка aggregatedBy — какие цели считают его строки (88-derived.sql)
+--   resolved  развёрнутое описание с учётом предков — пишет триггер, присланное значение перезаписывается
 -- Скомпилированная проверка данных класса лежит в колонке validator строки Class.
 
 create or replace function @SCHEMA@.class_metaschema() returns jsonb
@@ -62,35 +57,10 @@ return $json${
       }
     },
     "key": {"type": "array", "items": {"type": "string"}, "uniqueItems": true},
-    "history": {"anyOf": [{"type": "boolean"}, {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["all"],
-      "properties": {
-        "all": {"type": "string"}, "daily": {"type": "string"}, "weekly": {"type": "string"},
-        "monthly": {"type": "string"}, "yearly": {"type": "string"}, "tz": {"type": "string"}
-      }
-    }]},
+    "history": {"type": "boolean"},
     "ownerDefault": {"type": "string", "enum": ["tenant", "actor"]},
     "cache": {"type": "object"},
     "meta": {"type": "object"},
-    "derivedBy": {"type": "string", "pattern": "^[a-z0-9][a-z0-9_.:-]{0,63}$"},
-    "aggregate": {
-      "type": "object",
-      "propertyNames": {"type": "string", "pattern": "^[^$]"},
-      "additionalProperties": {
-        "type": "object",
-        "required": ["of", "via"],
-        "additionalProperties": false,
-        "properties": {
-          "sum": {"type": "string", "pattern": "^[^$]"},
-          "count": {"type": "boolean", "enum": [true]},
-          "of": {"type": "string", "pattern": "^[A-Za-zА-Яа-яЁё_][A-Za-zА-Яа-яЁё0-9_]{0,62}$"},
-          "via": {"type": "string", "pattern": "^[A-Za-zА-Яа-яЁё_][A-Za-zА-Яа-яЁё0-9_]{0,62}$"},
-          "where": {"type": "object"}
-        }
-      }
-    },
     "resolved": {"type": "object"}
   }
 }$json$::jsonb;
@@ -103,11 +73,12 @@ begin
   select c.rules, c.validator, c.vars into rules, validator, vars from @SCHEMA@.compile_validator(@SCHEMA@.class_metaschema()) c;
 end $$;
 
--- Строка класса по имени: собственная строка арендатора или системная. Поиск — по индексу
+-- Строка класса по имени: собственная строка арендатора, иначе системная. Поиск — по индексу
 -- entity_class_name, без вычисления v5 (два SHA-1 стоили 30 мкс на поиск, а запись ищет описание
--- несколько раз). Пара «арендатор, имя» однозначна: id строки Class — v5 от имени. Имя
--- пользовательского класса не совпадает с именем системного (проверка при определении), поэтому
--- порядок нужен только для ясности. Нет строки — null.
+-- несколько раз). Пара «арендатор, имя» однозначна: id строки Class — v5 от имени. Порядок важен:
+-- арендатор не заведёт класс с именем уже существующего класса System (class_admit,
+-- system_name_taken), но класс System может появиться позже одноимённого класса арендатора — тогда
+-- строк две, и действует собственная (атака №54 в engine-attacks). Нет строки — null.
 create or replace function @SCHEMA@.class_row(p_name text, p_tenant uuid) returns @SCHEMA@.entity
 language sql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -136,8 +107,6 @@ declare
   hist jsonb;
   od text;
   cache jsonb;
-  der text;
-  agg jsonb;
   comp jsonb := '{}';
   i int;
   v jsonb;
@@ -146,10 +115,10 @@ begin
   while cur->>'parent' is not null loop
     cur := (@SCHEMA@.class_row(cur->>'parent', p_tenant)).data;
     if cur is null then
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('предок %s не найден', chain[cardinality(chain)]->>'parent'));
+      perform @SCHEMA@.lt_fail('sql-core.parent_not_found', jsonb_build_object('parent', chain[cardinality(chain)]->>'parent'));
     end if;
     if cur->>'name' = any (names) then
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', 'цикл в наследовании через ' || (cur->>'name'));
+      perform @SCHEMA@.lt_fail('sql-core.inheritance_cycle', jsonb_build_object('cls', cur->>'name'));
     end if;
     names := names || (cur->>'name');
     chain := chain || cur;
@@ -167,16 +136,6 @@ begin
     if v ? 'history' then hist := v->'history'; end if;
     if v ? 'ownerDefault' then od := v->>'ownerDefault'; end if;
     if v ? 'cache' then cache := v->'cache'; end if;
-    -- производный класс (план 1.1, §2.4): проектор задаёт предок, потомок его не меняет
-    if v ? 'derivedBy' then
-      if der is not null and der <> v->>'derivedBy' then
-        perform @SCHEMA@.lt_raise('LT010', 'invalid_class',
-          format('derivedBy класса %s (%s) не совпадает с предком (%s)', v->>'name', v->>'derivedBy', der));
-      end if;
-      der := v->>'derivedBy';
-    end if;
-    -- агрегаты (план 1.1, §2.4): потомок заменяет описание предка целиком, {} — снимает унаследованное
-    if v ? 'aggregate' then agg := v->'aggregate'; end if;
     for m in select * from jsonb_each(coalesce(v->'meta', '{}')) loop
       if m.value = 'null'::jsonb then meta := meta - m.key; else meta := meta || jsonb_build_object(m.key, m.value); end if;
     end loop;
@@ -192,12 +151,10 @@ begin
     'history', coalesce(hist, 'true'),
     'ownerDefault', coalesce(od, 'tenant'),
     'cache', cache,
-    -- ключи только у производных и у целей агрегатов: у описаний до 1.2 их нет, и сравнение «было — стало» их не задевает
-    'meta', meta) || case when der is not null then jsonb_build_object('derivedBy', der) else '{}'::jsonb end
-                  || case when agg is not null and agg <> '{}'::jsonb then jsonb_build_object('aggregate', agg) else '{}'::jsonb end;
+    'meta', meta);
 end $$;
 
--- Проверка описания класса: метасхема, правила ключа (§2.3), правило unset (§2.10), размер meta.
+-- Проверка описания класса: метасхема, правила ключа (§2.3), правило unset (§2.10), размер meta, журнал системных классов.
 -- Возвращает строку с заполненными resolved и validator.
 create or replace function @SCHEMA@.class_prepare(p_data jsonb, p_tenant uuid, out data jsonb, out validator jsonpath)
 language plpgsql stable
@@ -211,18 +168,15 @@ declare
   fld jsonb;
   e record;
   c record;
-  prev interval;
-  tiers text[];
-  i int;
 begin
   data := p_data - 'resolved';
   select * into ms from @SCHEMA@.class_meta_validator();
   bad := @SCHEMA@.validate_data(ms.rules, ms.validator, ms.vars, data);
   if bad <> '[]'::jsonb then
-    perform @SCHEMA@.lt_raise('LT003', 'invalid_data', 'описание класса не проходит метасхему', jsonb_build_object('issues', bad));
+    perform @SCHEMA@.lt_fail('sql-core.class_metaschema', '{}'::jsonb, jsonb_build_object('issues', bad));
   end if;
   if octet_length(coalesce(data->'meta', '{}')::text) > 65536 then
-    perform @SCHEMA@.lt_raise('LT010', 'invalid_class', 'meta класса больше 64 КБ');
+    perform @SCHEMA@.lt_fail('sql-core.meta_too_large');
   end if;
   res := @SCHEMA@.class_resolve(data, p_tenant);
   -- ключ: только обязательные строковые поля и обязательные одиночные концы
@@ -230,85 +184,57 @@ begin
     fld := res->'schema'->'properties'->k;
     if fld is not null then
       if not (res->'schema'->'required' ? k) or coalesce(fld->>'type', '') <> 'string' then
-        perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('поле ключа %s должно быть обязательной строкой', k));
+        perform @SCHEMA@.lt_fail('sql-core.key_field_type', jsonb_build_object('field', k));
       end if;
     elsif res->'ends' ? k then
       if coalesce((res->'ends'->k->>'many')::boolean, false) or not coalesce((res->'ends'->k->>'required')::boolean, false) then
-        perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('конец ключа %s должен быть обязательным и одиночным', k));
+        perform @SCHEMA@.lt_fail('sql-core.key_end_type', jsonb_build_object('end', k));
       end if;
     else
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('ключ ссылается на неизвестное поле или конец %s', k));
+      perform @SCHEMA@.lt_fail('sql-core.key_unknown_name', jsonb_build_object('name', k));
     end if;
   end loop;
   -- unset — только для необязательного одиночного конца и множественного без min
   for e in select key, value from jsonb_each(res->'ends') loop
     if e.value->>'onDelete' = 'unset' and (coalesce((e.value->>'required')::boolean, false) or coalesce((e.value->>'min')::int, 0) > 0) then
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('onDelete unset недопустим для обязательного конца %s', e.key));
+      perform @SCHEMA@.lt_fail('sql-core.unset_required_end', jsonb_build_object('end', e.key));
     end if;
   end loop;
-  -- политика хранения: для системных классов запрещена (§2.11)
-  if coalesce((data->>'system')::boolean, false) and jsonb_typeof(res->'history') <> 'boolean' then
-    perform @SCHEMA@.lt_raise('LT010', 'invalid_class', 'системным классам политика хранения не задаётся');
-  end if;
+  -- журнал системных классов — аудит прав и схемы: его не выключают
   if coalesce((data->>'system')::boolean, false) and res->'history' = 'false'::jsonb then
-    perform @SCHEMA@.lt_raise('LT010', 'invalid_class', 'history: false для системных классов запрещён');
+    perform @SCHEMA@.lt_fail('sql-core.system_history_off');
   end if;
-  -- политика хранения (§2.11): сроки ярусов по возрастанию, all не меньше суток, 'forever' — только последний
-  if jsonb_typeof(res->'history') = 'object' then
-    prev := interval '0';
-    tiers := array(select u.tn from unnest(array['all', 'daily', 'weekly', 'monthly', 'yearly']) with ordinality u(tn, ord)
-                   where res->'history' ? u.tn order by u.ord);
-    for i in 1 .. cardinality(tiers) loop
-      k := res->'history'->>tiers[i];
-      if k = 'forever' then
-        if i <> cardinality(tiers) then
-          perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('history: forever допустим только у последнего яруса, а стоит у %s', tiers[i]));
-        end if;
-      elsif not pg_input_is_valid(k, 'interval') then
-        perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('history: срок яруса %s не разбирается: %s', tiers[i], k));
-      elsif k::interval <= prev then
-        perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('history: сроки ярусов должны возрастать (%s)', tiers[i]));
-      else
-        prev := k::interval;
-      end if;
-    end loop;
-    if (res->'history'->>'all') <> 'forever' and (res->'history'->>'all')::interval < interval '1 day' then
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', 'history: ярус all не меньше суток');
-    end if;
-    if res->'history' ? 'tz' and not exists (select 1 from pg_timezone_names where name = res->'history'->>'tz') then
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', format('history: неизвестный часовой пояс %s', res->'history'->>'tz'));
-    end if;
-  end if;
-  -- производный класс (план 1.1, §2.4): системным не бывает; его строки проектор удаляет и строит заново,
-  -- поэтому они не мешают удалять строки, на которые ссылаются (onDelete только cascade или unset)
-  if res ? 'derivedBy' then
-    if coalesce((data->>'system')::boolean, false) then
-      perform @SCHEMA@.lt_raise('LT010', 'invalid_class', 'системный класс не бывает производным');
-    end if;
-    for e in select key, value from jsonb_each(res->'ends') loop
-      if coalesce(e.value->>'onDelete', 'restrict') not in ('cascade', 'unset') then
-        perform @SCHEMA@.lt_raise('LT010', 'invalid_class',
-          format('конец %s производного класса — onDelete cascade или unset: производная строка не мешает удалять цель', e.key));
-      end if;
-    end loop;
-  end if;
-  -- агрегаты (план 1.1, §2.4; 88-derived.sql): цель — поля, источники, цикл, условия where; источник — метка
-  -- aggregatedBy и та же сверка против агрегатов, которые считают его строки (источник часто описывают после цели)
-  if res ? 'aggregate' then
-    res := @SCHEMA@.agg_prepare(res, data, p_tenant);
-  end if;
-  res := @SCHEMA@.agg_source(res, p_tenant);
   select * into c from @SCHEMA@.compile_validator(res->'schema');
   data := data || jsonb_build_object('resolved', res || jsonb_build_object('rules', c.rules, 'vars', c.vars));
   validator := c.validator;
 end $$;
 
+-- Нарушения данных строки класса по его описанию в базе, без записи (план 2.1, A8): валидатор на TypeScript не исполняет
+-- шаблоны pattern (ревью, ReDoS), и у класса с ними библиотека берёт полный список нарушений здесь. Класс — свой
+-- арендатора сессии или System, как у записи; умолчания подставляются, как перед проверкой при записи. Описание класса
+-- сессия и так видит (реестр), поэтому ответ ничего нового не открывает. Нет класса — null.
+create or replace function @SCHEMA@.validate_row(p_class text, p_data jsonb) returns jsonb
+language plpgsql stable security definer
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+declare
+  cls @SCHEMA@.entity;
+begin
+  cls := @SCHEMA@.class_row(p_class, @SCHEMA@.ctx_tenant());
+  if cls.id is null or cls.validator is null then
+    return null;
+  end if;
+  return @SCHEMA@.validate_data(cls.data->'resolved'->'rules', cls.validator, cls.data->'resolved'->'vars',
+    @SCHEMA@.apply_defaults(cls.data->'resolved'->'schema', p_data));
+end $$;
+
 do $$
 declare f text;
 begin
   foreach f in array array['class_metaschema()', 'class_meta_validator()', 'class_row(text, uuid)',
-    'class_resolve(jsonb, uuid)', 'class_prepare(jsonb, uuid)'] loop
+    'class_resolve(jsonb, uuid)', 'class_prepare(jsonb, uuid)', 'validate_row(text, 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;
 end $$;
+grant execute on function @SCHEMA@.validate_row(text, jsonb) to @APP@;

package/sql/50-acl.sql

@@ -306,7 +306,7 @@ declare
   c record;
 begin
   if p_op not in ('READ', 'WRITE', 'DELETE') then
-    perform @SCHEMA@.lt_fail('invalid_data', format('операция %s: нужна READ, WRITE или DELETE', p_op));
+    perform @SCHEMA@.lt_fail('sql-access.acl_bad_op', jsonb_build_object('op', p_op));
   end if;
   select * into c from @SCHEMA@.ctx();
   if c.account is null then
@@ -382,14 +382,14 @@ 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
-    perform @SCHEMA@.lt_fail('target_not_found', 'аккаунт не найден или отключён');
+    perform @SCHEMA@.lt_fail('sql-access.account_unavailable');
   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 or not exists (select 1 from @SCHEMA@.entity e where e.id = p_tenant and e.class = 'Account'
                                 and e.tenant = '@SYSTEM@'::uuid and coalesce((e.data->>'enabled')::boolean, true)) then
-      perform @SCHEMA@.lt_fail('tenant_denied', 'нет членства в арендаторе');
+      perform @SCHEMA@.lt_fail('sql-access.no_membership');
     end if;
   end if;
   cats := array(select jsonb_array_elements_text(coalesce(a->'categories', '[]'::jsonb)));
@@ -417,7 +417,7 @@ begin
       where @SCHEMA@.acl_endpoint_ok(r.pattern, p_endpoint)
       order by r.weight desc, r.deny desc, r.alias, r.id
       limit 1) w),
-    jsonb_build_object('allow', false, 'message', 'нет подходящего правила (запрет по умолчанию)'));
+    jsonb_build_object('allow', false, 'message', @SCHEMA@.lt_text('sql-access.default_deny')));
 end $$;
 
 -- db.acl.check(endpoint): решение для актора сессии по правилам System и его арендатора.
@@ -430,7 +430,7 @@ declare
 begin
   select * into c from @SCHEMA@.ctx();
   if c.account is null then
-    perform @SCHEMA@.lt_fail('no_session', 'нет действующей сессии');
+    perform @SCHEMA@.lt_fail('sql-access.no_session');
   end if;
   return @SCHEMA@.acl_api_for(c.tenant, c.categories, c.roles, p_endpoint, false);
 end $$;
@@ -445,10 +445,10 @@ declare
 begin
   select * into c from @SCHEMA@.ctx();
   if c.account is null then
-    perform @SCHEMA@.lt_fail('no_session', 'нет действующей сессии');
+    perform @SCHEMA@.lt_fail('sql-access.no_session');
   end if;
   if not coalesce((@SCHEMA@.acl_api_for(c.tenant, c.categories, c.roles, p_endpoint, true)->>'allow')::boolean, false) then
-    perform @SCHEMA@.lt_fail('acl_denied', format('нет права %s', p_endpoint));
+    perform @SCHEMA@.lt_fail('sql-access.no_right', jsonb_build_object('endpoint', p_endpoint));
   end if;
 end $$;
 
@@ -479,9 +479,7 @@ return (p_tenant = c_tenant and (p_class = 'Class' or @SCHEMA@.acl_row_ok(c_plan
     or (p_class = 'Account' and p_id = c_account)
     or (p_class = 'member' and p_links->>'User' = c_account::text);
 
--- до этапа 5 видимость не зависела от прав
-drop function if exists @SCHEMA@.row_visible(uuid, text, uuid, uuid, uuid);
-
+-- Политики: create policy не знает or replace — повторный накат пересоздаёт их (drop policy if exists и create policy).
 drop policy if exists entity_select on @SCHEMA@.entity;
 create policy entity_select on @SCHEMA@.entity for select to @APP@
   using (
@@ -520,9 +518,6 @@ create policy log_select on @SCHEMA@.log for select to @APP@
     or (class = 'member' and links->>'User' = (select @SCHEMA@.ctx_account())::text)
   );
 
--- ранняя редакция этапа 5: проверка строки по одной карте плана в политиках
-drop function if exists @SCHEMA@.acl_ok(jsonb, text, uuid, uuid, uuid, text[], jsonb, jsonb);
-
 do $$
 declare f text;
 begin