letopis 0.5.0 → 0.13.0

package/dist/chain.d.ts

@@ -1,19 +1,22 @@
 /**
- * Dot-цепочки: db.Сотрудник({name:'Вася'}).навык().Услуга().execute()
+ * Dot-цепочки: db.Сотрудник({name:'Вася'}).навык().Услуга().run()
  * db и цепочка — Proxy над реестром классов (id и alias работают одинаково).
  *
  * Выборка настраивается модификаторами: .limit(n) .offset(n) .sort(field, dir?)
  * Колонки — модификаторами: .tags(…) .account(…) .owner(…); ключ путей — .alias(…).
- * Запись: .set(data) — связи задаются контекст-шагами цепочки; .delete().
+ * Запись: .set(data) / .delete({confirm}) / .anonymize(fields) — ЗВЕНЬЯ (возвращают
+ * цепочку, продолжение — от результата); исполняет ТЕРМИНАЛ, весь план одной транзакцией.
  */
 import type { Row, Path, Filter } from './types.js';
 import { type Ctx } from './sql.js';
-import { type BatchOp } from './write.js';
+import { type BatchPlan } from './write.js';
 import { type Tables } from './tables.js';
+import { type AuthApi } from './auth.js';
+import { type AclApi } from './acl.js';
 import type { Registry } from './schema.js';
 export interface ChainCore {
-    /** Пути: [{шаг1: Row, шаг2: Row, …}, …] — все узлы каждого варианта. */
-    execute(): Promise<Path[]>;
+    /** Пути: [{шаг1: Row, шаг2: Row, …}, …] — все узлы каждого варианта (бывший execute). */
+    run(): Promise<Path[]>;
     /** Уникальные сущности последнего шага. */
     rows(): Promise<Row[]>;
     first(): Promise<Row | null>;
@@ -39,8 +42,11 @@ export interface ChainCore {
     min(field: string): Promise<unknown>;
     max(field: string): Promise<unknown>;
     countBy(field: string): Promise<Record<string, number>>;
-    /** GDPR: новая версия с затёртыми string-полями ('[erased]') + тег 'anonymized'. История остаётся (см. README). */
-    anonymize(fields: string[]): Promise<Row[]>;
+    /**
+     * GDPR-звено: новая версия с затёртыми string-полями ('[erased]') + тег 'anonymized'.
+     * История остаётся. Возвращает цепочку — исполняет терминал; продолжение — от затёртых версий.
+     */
+    anonymize(fields: string[]): Chain;
     /** Переименовать ключ ТЕКУЩЕГО шага в выводе путей. */
     alias(name: string): Chain;
     /** Колонка tags: строка | string[] (все) | has/hasAny/hasAll. В set() — значение тегов. */
@@ -54,23 +60,29 @@ export interface ChainCore {
         id: string;
     }): Chain;
     /**
-     * Записать. Связи — контекст-шагами до set() И/ИЛИ класс-вызовами после:
-     *   await db.Сотрудник(s).занятость(id).set({kind}).Окно(w)
-     *   const z = db.занятость(id).set({kind}); z.Сотрудник(s); z.Окно(w); await z
-     * Исполняется ОДНИМ INSERT при первом await (промис кешируется).
-     * Пустой фильтр без data.id → INSERT; id (фильтр или data.id) → UPSERT;
-     * фильтр-объект → версия каждого найденного.
+     * Значение связи для записи БЕЗ участия в фильтре целей (в отличие от контекст-шага):
+     *   tr.Запись(b).позиция({}).link('Сотрудник', новый).set({}).rows()  // перевесить исполнителя
      */
-    set(data?: Record<string, unknown>): SetChain;
-    /** Серверный tombstone + каскад; возвращает всё удалённое с $deleted: true. */
-    delete(): Promise<Row[]>;
-}
-/** Ленивый билдер записи: довешивание связей + thenable (исполнение при await). */
-export type SetChain = PromiseLike<Row[]> & {
-    [className: string]: (target: string | {
+    link(className: string, target: string | {
         id: string;
-    }) => SetChain;
-};
+    }): Chain;
+    /**
+     * Записать в шаг, к которому приклеен точкой (ЗВЕНО — вернёт цепочку, исполняет терминал):
+     *   await db.Организация(org).Сотрудник().set({ name: 'Вася' }).rows()
+     * Связи — контекст-шагами до set(). Пустой фильтр без data.id → INSERT;
+     * id (фильтр или data.id) → UPSERT; фильтр-объект → версия каждого найденного.
+     * Продолжение цепочки — от записанных строк (fan-out при множестве).
+     */
+    set(data?: Record<string, unknown>): Chain;
+    /**
+     * Удаление-звено. { confirm: true } — серверный tombstone + каскад (продолжение — от
+     * затомбстоуненных, $deleted: true); БЕЗ confirm — превью: терминал вернёт кандидатов
+     * (цели + каскад), БД не тронута.
+     */
+    delete(opts?: {
+        confirm?: boolean;
+    }): Chain;
+}
 export type Chain = ChainCore & {
     [className: string]: (filter?: Filter) => Chain;
 };
@@ -79,13 +91,16 @@ export interface DbCore {
     begin(): Promise<EntityTx>;
     commit(tr: EntityTx): Promise<void>;
     rollback(tr: EntityTx): Promise<void>;
-    /** Именованный батч: те же цепочки, set/delete копятся до execute(). */
+    /** Именованный батч: те же цепочки, планы записи копятся до run(). */
     batch(name: string): Batch;
     /**
      * Realtime: события каждой вставленной версии (insert/update/delete-tombstone).
      * watch(cb) — все классы; watch('Запись', cb) — один. Возврат — stop-функция.
+     * LISTEN-соединение переживает обрывы (re-listen автоматом), но NOTIFY за время
+     * разрыва потеряны — opts.onReconnect зовётся после восстановления: дочитайте пропущенное.
      */
-    watch(classOrCb: string | ((e: WatchEvent) => void), cb?: (e: WatchEvent) => void): Promise<() => void>;
+    watch(cb: (e: WatchEvent) => void, opts?: WatchOpts): Promise<() => void>;
+    watch(cls: string, cb: (e: WatchEvent) => void, opts?: WatchOpts): Promise<() => void>;
     close(): Promise<void>;
     registry: Registry;
     /** Голый postgres-клиент (тесты, EXPLAIN). */
@@ -95,6 +110,10 @@ export interface DbCore {
     credentials: Tables['credentials'];
     resources: Tables['resources'];
     rules: Tables['rules'];
+    /** Вход по кредам (пароль/api-key/key-secret/внешние identity) + сессии в Redis. */
+    auth: AuthApi;
+    /** ACL по Resource/Rule: check(эндпоинт) / checkData(класс, READ|WRITE|DELETE) / reload. */
+    acl: AclApi;
 }
 export type EntityDb = DbCore & {
     [className: string]: (filter?: Filter) => Chain;
@@ -112,15 +131,21 @@ export interface WatchEvent {
     updated: string;
     deleted: boolean;
 }
+/** Опции watch(): реакция на восстановление LISTEN-соединения. */
+export interface WatchOpts {
+    /** Зовётся после каждого re-listen (не на первом подключении): NOTIFY за разрыв потеряны. */
+    onReconnect?: () => void;
+}
 export type Batch = {
-    execute(): Promise<Row[][]>;
+    /** Исполнить всю очередь планов одной транзакцией (бывший execute). */
+    run(): Promise<Row[][]>;
     discard(): void;
     size(): number;
 } & {
     [className: string]: (filter?: Filter) => Chain;
 };
 interface RootState {
-    batches: Map<string, BatchOp[]>;
+    batches: Map<string, BatchPlan[]>;
 }
 export declare function makeDb(ctx: Ctx, root?: RootState): EntityDb;
 export {};

package/dist/chain.js

@@ -1,7 +1,9 @@
-import { buildRead, runQuery } from './sql.js';
-import { setOp, delOp, anonymizeOp, executeBatch, toRow } from './write.js';
+import { buildRead, runQuery, leafType } from './sql.js';
+import { runPlan, executeBatch, toRow } from './write.js';
 import { beginTx, lock } from './tx.js';
 import { makeTables } from './tables.js';
+import { makeAuth } from './auth.js';
+import { makeAcl } from './acl.js';
 /** Фильтр-аргумент принимает и Row/Account-объект — берётся его id. */
 function normalizeFilter(f) {
     if (f !== undefined &&
@@ -33,65 +35,79 @@ async function runRows(ctx, steps, mods) {
         return d != null ? { ...row, $depth: d } : row;
     });
 }
-const idOf = (t) => (typeof t === 'object' ? t.id : t);
-/**
- * Ленивый билдер set(): класс-вызовы довешивают связи (мутирует), await исполняет один раз.
- * run() — исполнение (сразу setOp или отложенно через батч); links — общая ссылка,
- * которую батч читает на execute().
- */
-function makeSetChain(registry, links, run) {
-    let done;
-    const handler = {
-        get(_t, prop) {
-            if (typeof prop === 'symbol')
-                return undefined;
-            if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-                done ??= run();
-                const m = done[prop];
-                return m.bind(done);
-            }
-            if (registry.has(prop)) {
-                const cls = registry.resolve(prop);
-                return (target) => {
-                    if (done)
-                        throw new Error(`letopis: set() already executed — link "${prop}" before the first await`);
-                    links[cls.id] = idOf(target);
-                    return proxy;
-                };
-            }
-            registry.resolve(prop);
-            return undefined;
-        },
-    };
-    const proxy = new Proxy({}, handler);
-    return proxy;
-}
-function makeChain(ctx, steps, mods, batchQueue) {
+function makeChain(ctx, steps, mods, batch) {
+    const hasOps = steps.some((s) => s.op);
     const withLast = (patch) => {
+        const last = steps[steps.length - 1];
+        if (last.op) {
+            throw new Error(`letopis: step modifier after ${last.op.kind}() — add a class step first`);
+        }
         const next = steps.slice();
-        next[next.length - 1] = { ...next[next.length - 1], ...patch };
-        return makeChain(ctx, next, mods, batchQueue);
+        next[next.length - 1] = { ...last, ...patch };
+        return makeChain(ctx, next, mods, batch);
+    };
+    const withMods = (patch) => makeChain(ctx, steps, { ...mods, ...patch }, batch);
+    /** Операция-звено: op на последний шаг (op уже есть → self-шаг «те же сущности»); mods сбрасываются. */
+    const withOp = (op) => {
+        const last = steps[steps.length - 1];
+        const next = last.op
+            ? [...steps, { name: last.name, cls: last.cls, self: true, op }]
+            : [...steps.slice(0, -1), { ...last, op }];
+        if (batch) {
+            if (batch.entry)
+                batch.entry.steps = next;
+            else {
+                batch.entry = { steps: next };
+                batch.queue.push(batch.entry);
+            }
+        }
+        return makeChain(ctx, next, {}, batch);
+    };
+    /** Терминал: план (есть операции) — runPlan одной транзакцией; иначе прямое чтение. */
+    const guardBatch = () => {
+        if (batch && hasOps) {
+            throw new Error('letopis: plan is queued in the batch — call batch.run()');
+        }
     };
-    const withMods = (patch) => makeChain(ctx, steps, { ...mods, ...patch }, batchQueue);
     const handler = {
         get(_t, prop) {
             if (typeof prop === 'symbol' || prop === 'then')
                 return undefined;
             switch (prop) {
+                case 'run':
+                    return () => {
+                        guardBatch();
+                        return hasOps ? runPlan(ctx, steps, mods, 'paths') : runPaths(ctx, steps, mods);
+                    };
                 case 'execute':
-                    return () => runPaths(ctx, steps, mods);
+                    throw new Error('letopis: execute() renamed to run() (0.11.0)');
                 case 'rows':
-                    return () => runRows(ctx, steps, mods);
+                    return () => {
+                        guardBatch();
+                        return hasOps ? runPlan(ctx, steps, mods, 'rows') : runRows(ctx, steps, mods);
+                    };
                 case 'first':
-                    return async () => (await runRows(ctx, steps, { ...mods, limit: 1 }))[0] ?? null;
+                    return async () => {
+                        guardBatch();
+                        const rows = hasOps
+                            ? (await runPlan(ctx, steps, mods, 'rows'))
+                            : await runRows(ctx, steps, { ...mods, limit: 1 });
+                        return rows[0] ?? null;
+                    };
                 case 'ids':
                     return async () => {
+                        guardBatch();
+                        if (hasOps)
+                            return runPlan(ctx, steps, mods, 'ids');
                         const q = buildRead(ctx, steps, mods, 'ids');
                         const res = await runQuery(ctx, q.text, q.params, 'ids', clsOf(steps));
                         return res.map((r) => r.id);
                     };
                 case 'count':
                     return async () => {
+                        guardBatch();
+                        if (hasOps)
+                            return runPlan(ctx, steps, mods, 'count');
                         const q = buildRead(ctx, steps, mods, 'count');
                         const res = await runQuery(ctx, q.text, q.params, 'count', clsOf(steps));
                         return res[0].n;
@@ -111,21 +127,44 @@ function makeChain(ctx, steps, mods, batchQueue) {
                 case 'min':
                 case 'max':
                     return async (field) => {
-                        const q = buildRead(ctx, steps, { ...mods, aggFn: prop, aggField: field }, 'agg');
-                        const res = await runQuery(ctx, q.text, q.params, 'agg', clsOf(steps));
+                        guardBatch();
+                        const aggMods = { ...mods, aggFn: prop, aggField: field };
+                        const res = hasOps
+                            ? (await runPlan(ctx, steps, aggMods, 'agg'))
+                            : await (async () => {
+                                const q = buildRead(ctx, steps, aggMods, 'agg');
+                                return runQuery(ctx, q.text, q.params, 'agg', clsOf(steps));
+                            })();
                         const v = res[0]?.v;
-                        return v === null || v === undefined ? null : typeof v === 'string' && prop !== 'min' && prop !== 'max' ? Number(v) : v;
+                        if (v === null || v === undefined)
+                            return null;
+                        if (typeof v !== 'string')
+                            return v;
+                        if (prop === 'sum' || prop === 'avg')
+                            return Number(v);
+                        // min/max: postgres.js отдаёт numeric строкой — приводим, если лист числовой по Schema
+                        const leaf = leafType(steps[steps.length - 1].cls, field.slice(5).split('.'));
+                        return leaf?.kind === 'number' ? Number(v) : v;
                     };
                 case 'countBy':
                     return async (field) => {
-                        const q = buildRead(ctx, steps, { ...mods, aggFn: 'countBy', aggField: field }, 'agg');
-                        const res = await runQuery(ctx, q.text, q.params, 'agg', clsOf(steps));
+                        guardBatch();
+                        const aggMods = { ...mods, aggFn: 'countBy', aggField: field };
+                        const res = hasOps
+                            ? (await runPlan(ctx, steps, aggMods, 'agg'))
+                            : await (async () => {
+                                const q = buildRead(ctx, steps, aggMods, 'agg');
+                                return runQuery(ctx, q.text, q.params, 'agg', clsOf(steps));
+                            })();
                         return Object.fromEntries(res.map((r) => [r.k ?? 'null', r.n]));
                     };
                 case 'after':
                     return (cursor) => withMods({ after: cursor });
                 case 'versions':
                     return async () => {
+                        guardBatch();
+                        if (hasOps)
+                            return runPlan(ctx, steps, mods, 'versions');
                         const q = buildRead(ctx, steps, mods, 'versions');
                         const res = await runQuery(ctx, q.text, q.params, 'versions', clsOf(steps));
                         return res.map((r) => {
@@ -134,8 +173,12 @@ function makeChain(ctx, steps, mods, batchQueue) {
                             return raw.deleted ? { ...row, $deleted: true } : row;
                         });
                     };
+                case 'set':
+                    return (data = {}) => withOp({ kind: 'set', data, mods });
+                case 'delete':
+                    return (opts) => withOp({ kind: 'delete', confirm: opts?.confirm === true, mods });
                 case 'anonymize':
-                    return (fields) => anonymizeOp(ctx, steps, mods, fields);
+                    return (fields) => withOp({ kind: 'anonymize', fields, mods });
                 case 'alias':
                     return (name) => withLast({ aliasKey: name });
                 case 'tags':
@@ -144,30 +187,18 @@ function makeChain(ctx, steps, mods, batchQueue) {
                     return (v) => withLast({ accountFilter: typeof v === 'object' ? v.id : v });
                 case 'owner':
                     return (v) => withLast({ ownerFilter: typeof v === 'object' ? v.id : v });
-                case 'set':
-                    return (data = {}) => {
-                        const extraLinks = {};
-                        if (batchQueue) {
-                            const op = { kind: 'set', steps, mods, data, extraLinks };
-                            batchQueue.push(op);
-                            const index = batchQueue.length - 1;
-                            // билдер для довешивания связей; await возвращает № в очереди
-                            return makeSetChain(ctx.registry, extraLinks, async () => index);
-                        }
-                        return makeSetChain(ctx.registry, extraLinks, () => setOp(ctx, steps, mods, data, extraLinks));
-                    };
-                case 'delete':
-                    return () => {
-                        if (batchQueue) {
-                            batchQueue.push({ kind: 'delete', steps, mods });
-                            return batchQueue.length - 1;
-                        }
-                        return delOp(ctx, steps, mods);
+                case 'link':
+                    return (clsName, target) => {
+                        const linkCls = ctx.registry.resolve(clsName);
+                        const last = steps[steps.length - 1];
+                        return withLast({
+                            extraLinks: { ...(last.extraLinks ?? {}), [linkCls.id]: typeof target === 'object' ? target.id : target },
+                        });
                     };
             }
             if (ctx.registry.has(prop)) {
                 const cls = ctx.registry.resolve(prop);
-                return (filter) => makeChain(ctx, [...steps, { name: prop, cls, filter: normalizeFilter(filter) }], mods, batchQueue);
+                return (filter) => makeChain(ctx, [...steps, { name: prop, cls, filter: normalizeFilter(filter) }], mods, batch);
             }
             ctx.registry.resolve(prop); // неизвестный класс — понятная ошибка со списком
             return undefined;
@@ -181,11 +212,13 @@ function makeBatch(ctx, queue) {
             if (typeof prop === 'symbol' || prop === 'then')
                 return undefined;
             switch (prop) {
-                case 'execute':
+                case 'run':
                     return async () => {
-                        const ops = queue.splice(0, queue.length);
-                        return executeBatch(ctx, ops);
+                        const plans = queue.splice(0, queue.length);
+                        return executeBatch(ctx, plans);
                     };
+                case 'execute':
+                    throw new Error('letopis: batch.execute() renamed to batch.run() (0.11.0)');
                 case 'discard':
                     return () => void queue.splice(0, queue.length);
                 case 'size':
@@ -193,7 +226,7 @@ function makeBatch(ctx, queue) {
             }
             if (ctx.registry.has(prop)) {
                 const cls = ctx.registry.resolve(prop);
-                return (filter) => makeChain(ctx, [{ name: String(prop), cls, filter: normalizeFilter(filter) }], {}, queue);
+                return (filter) => makeChain(ctx, [{ name: String(prop), cls, filter: normalizeFilter(filter) }], {}, { queue });
             }
             ctx.registry.resolve(prop);
             return undefined;
@@ -204,6 +237,8 @@ function makeBatch(ctx, queue) {
 export function makeDb(ctx, root) {
     const state = root ?? { batches: new Map() };
     let tables; // лениво, на ctx этого фасада (работает и в tr)
+    let auth;
+    let acl;
     const handler = {
         get(_t, prop) {
             if (typeof prop === 'symbol' || prop === 'then')
@@ -212,6 +247,16 @@ export function makeDb(ctx, root) {
                 tables ??= makeTables(ctx);
                 return tables[prop];
             }
+            if (prop === 'auth') {
+                tables ??= makeTables(ctx);
+                auth ??= makeAuth(tables);
+                return auth;
+            }
+            if (prop === 'acl') {
+                tables ??= makeTables(ctx);
+                acl ??= makeAcl(tables, ctx.registry);
+                return acl;
+            }
             switch (prop) {
                 case 'begin':
                     return async () => makeDb(await beginTx(ctx), state);
@@ -245,18 +290,42 @@ export function makeDb(ctx, root) {
                         return makeBatch(ctx, q);
                     };
                 case 'watch':
-                    return async (a, b) => {
+                    return async (a, b, c) => {
                         const cls = typeof a === 'string' ? ctx.registry.resolve(a).id : undefined;
                         const cb = typeof a === 'function' ? a : b;
+                        const opts = (typeof a === 'function' ? b : c) ?? {};
                         const listener = (payload) => {
                             const e = JSON.parse(payload);
                             if (e.partition !== ctx.partition)
                                 return;
                             if (cls && e.class !== cls)
                                 return;
+                            // enforceAcl: отдаём только при БЕЗУСЛОВНОМ allow — payload не содержит
+                            // owner/account/data, предикат строки проверить нечем (id — тоже утечка)
+                            if (ctx.aclDecide) {
+                                try {
+                                    const d = ctx.aclDecide(ctx.registry.resolve(e.class), 'READ');
+                                    if (!d.allow || d.filter)
+                                        return;
+                                }
+                                catch {
+                                    return;
+                                }
+                            }
                             cb(e);
                         };
-                        const { unlisten } = await ctx.sql.listen(ctx.pgSchema, listener);
+                        // postgres.js: dedicated LISTEN-соединение само переподключается (backoff) и
+                        // повторяет LISTEN; onlisten зовётся на первом connect И на каждом re-listen.
+                        // NOTIFY за время разрыва потеряны — onReconnect даёт точку дочитать пропущенное.
+                        let first = true;
+                        const onlisten = () => {
+                            if (first) {
+                                first = false;
+                                return;
+                            }
+                            opts.onReconnect?.();
+                        };
+                        const { unlisten } = await ctx.sql.listen(ctx.pgSchema, listener, onlisten);
                         return unlisten;
                     };
                 case 'close':

package/dist/index.d.ts

@@ -1,11 +1,17 @@
 import { type EntityDb } from './chain.js';
 import type { ConnectOpts } from './types.js';
 export declare function connect(opts: ConnectOpts): Promise<EntityDb>;
-/** Курсор keyset-пагинации из последней строки страницы (field как в .sort()). */
+/** Курсор keyset-пагинации из последней строки страницы (field как в .sort(), вложенные пути поддержаны). */
 export declare function cursorOf(row: import('./types.js').Row, field?: string): import('./types.js').Cursor;
+export { up } from './up.js';
+export type { UpOpts } from './up.js';
 export { ne, gt, gte, lt, lte, between, inList, like, ilike, starts, ends, has, hasAny, hasAll, exists, isNull, not, or, } from './ops.js';
-export type { Row, Path, Filter, ChainMods, Cursor, ConnectOpts, QueryEvent, Account, Credential, Resource, Rule, } from './types.js';
-export type { EntityDb, EntityTx, Chain, Batch } from './chain.js';
+export type { Row, Path, Filter, ChainMods, Cursor, ConnectOpts, QueryEvent, Account, Credential, Resource, Rule, AclOp, AclDecision, } from './types.js';
+export type { EntityDb, EntityTx, Chain, Batch, WatchEvent, WatchOpts } from './chain.js';
 export type { Tables, AccountsApi, CredentialsApi, ResourcesApi, RulesApi } from './tables.js';
+export { totpCode } from './auth.js';
+export type { AuthApi, AuthResult } from './auth.js';
+export type { AclApi } from './acl.js';
+export type { SessionStore, Sessions, Session } from './sessions.js';
 export { ValidationError } from './write.js';
 export { Registry } from './schema.js';

package/dist/index.js

@@ -2,11 +2,13 @@
  * letopis: dot-цепочки над append-only Entity-хранилищем (TimescaleDB).
  *
  *   const db = await connect({ dsn, schema: 'booking' })
- *   await db.Сотрудник({ name: 'Вася' }).навык().Услуга().execute()
+ *   await db.Сотрудник({ name: 'Вася' }).навык().Услуга().run()
  */
 import postgres from 'postgres';
 import { loadRegistry } from './schema.js';
 import { makeDb } from './chain.js';
+import { makeTables } from './tables.js';
+import { compileEnforcer } from './acl.js';
 export async function connect(opts) {
     // timestamptz — строкой (JS Date режет микросекунды → ломал бы asOf/cursorOf по updated)
     const sql = postgres(opts.dsn, {
@@ -30,14 +32,33 @@ export async function connect(opts) {
         onQuery: opts.onQuery,
         slowMs: opts.slowMs,
     };
+    // enforceAcl: правила и категории субъекта фиксируются на connect (перечитка — новый connect)
+    if (opts.enforceAcl) {
+        if (!opts.account)
+            throw new Error('letopis: enforceAcl requires connect({ account })');
+        const tables = makeTables(ctx);
+        const [account, resources, rules] = await Promise.all([
+            tables.accounts.get(opts.account),
+            tables.resources.find(),
+            tables.rules.find({ enabled: true }),
+        ]);
+        if (!account)
+            throw new Error(`letopis: enforceAcl — account "${opts.account}" not found`);
+        ctx.aclDecide = compileEnforcer({ resources, rules }, account.id, account.categories, registry);
+    }
     return makeDb(ctx);
 }
-/** Курсор keyset-пагинации из последней строки страницы (field как в .sort()). */
+/** Курсор keyset-пагинации из последней строки страницы (field как в .sort(), вложенные пути поддержаны). */
 export function cursorOf(row, field = 'updated') {
-    const v = field === 'updated' ? row.updated : row.data[field.slice(5)];
+    const v = field === 'updated'
+        ? row.updated
+        : field.slice(5).split('.').reduce((o, k) => o?.[k], row.data);
     return { v, id: row.id };
 }
+// одна точка входа: контейнер + готовность + схема + connect
+export { up } from './up.js';
 // операторы фильтров
 export { ne, gt, gte, lt, lte, between, inList, like, ilike, starts, ends, has, hasAny, hasAll, exists, isNull, not, or, } from './ops.js';
+export { totpCode } from './auth.js';
 export { ValidationError } from './write.js';
 export { Registry } from './schema.js';

package/dist/schema.js

@@ -62,6 +62,17 @@ export function fieldTypeOf(attr) {
         const t = attr.type;
         if (t === 'record')
             return { kind: 'record', value: fieldTypeOf(attr.value ?? 'any') };
+        if (t === 'object') {
+            // вложенная структура: {type:'object', props:{…}} — типы листьев любой глубины
+            const props = attr.props ?? attr.properties;
+            if (props && typeof props === 'object') {
+                const m = new Map();
+                for (const [k, v] of Object.entries(props))
+                    m.set(k, fieldTypeOf(v));
+                return { kind: 'object', props: m };
+            }
+            return { kind: 'any' };
+        }
         if (t === 'array')
             return { kind: 'array' };
         if (t === 'number')

package/dist/sessions.d.ts

@@ -0,0 +1,32 @@
+/** Минимальный срез Redis-клиента (ioredis подходит как есть). */
+export interface SessionStore {
+    set(key: string, value: string, mode: 'EX', ttlSec: number): Promise<unknown>;
+    get(key: string): Promise<string | null>;
+    del(...keys: string[]): Promise<unknown>;
+    sadd(key: string, ...members: string[]): Promise<unknown>;
+    srem(key: string, ...members: string[]): Promise<unknown>;
+    smembers(key: string): Promise<string[]>;
+    expire(key: string, ttlSec: number): Promise<unknown>;
+}
+export interface Session {
+    account: string;
+    meta: Record<string, unknown>;
+    created: string;
+}
+export interface Sessions {
+    /** Новая сессия → токен (отдаётся один раз; в Redis — только его sha256). Default ttl 7 суток. */
+    start(account: string | {
+        id: string;
+    }, opts?: {
+        ttlSec?: number;
+        meta?: Record<string, unknown>;
+    }): Promise<string>;
+    /** null — нет/просрочена/отозвана. */
+    check(token: string): Promise<Session | null>;
+    revoke(token: string): Promise<boolean>;
+    /** Гасит все сессии аккаунта, возвращает сколько было в индексе. */
+    revokeAll(account: string | {
+        id: string;
+    }): Promise<number>;
+}
+export declare function makeSessions(store: SessionStore): Sessions;

package/dist/sessions.js

@@ -0,0 +1,48 @@
+/**
+ * Сессии во внешнем KV (Redis): db.auth.sessions(store).
+ * Клиент НЕ входит в зависимости — инжектируется пользователем (интерфейс ioredis-совместим).
+ * В store лежит только sha256-хэш токена: дамп Redis не раскрывает действующие токены.
+ */
+import { createHash, randomBytes } from 'node:crypto';
+const sha256 = (s) => createHash('sha256').update(s).digest('hex');
+const accId = (a) => (typeof a === 'object' ? a.id : a);
+const DEFAULT_TTL = 7 * 24 * 3600;
+export function makeSessions(store) {
+    const kTok = (h) => `sess:${h}`;
+    // индекс аккаунта без TTL: протухшие хэши безвредны, полная чистка — revokeAll
+    const kAcc = (id) => `sess:acc:${id}`;
+    return {
+        async start(account, opts = {}) {
+            const id = accId(account);
+            const token = randomBytes(32).toString('hex');
+            const h = sha256(token);
+            const ttl = opts.ttlSec ?? DEFAULT_TTL;
+            const payload = { account: id, meta: opts.meta ?? {}, created: new Date().toISOString() };
+            await store.set(kTok(h), JSON.stringify(payload), 'EX', ttl);
+            await store.sadd(kAcc(id), h);
+            return token;
+        },
+        async check(token) {
+            const raw = await store.get(kTok(sha256(token)));
+            return raw ? JSON.parse(raw) : null;
+        },
+        async revoke(token) {
+            const h = sha256(token);
+            const raw = await store.get(kTok(h));
+            if (!raw)
+                return false;
+            const { account } = JSON.parse(raw);
+            await store.del(kTok(h));
+            await store.srem(kAcc(account), h);
+            return true;
+        },
+        async revokeAll(account) {
+            const id = accId(account);
+            const hs = await store.smembers(kAcc(id));
+            if (hs.length)
+                await store.del(...hs.map(kTok));
+            await store.del(kAcc(id));
+            return hs.length;
+        },
+    };
+}