letopis 0.5.0 → 0.16.0

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, resolveHop, nextNodeKey, } 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 &&
@@ -14,6 +16,44 @@ function normalizeFilter(f) {
     return f;
 }
 const clsOf = (steps) => steps.map((s) => s.cls.id);
+/** Внутренний канал: план чужой ленивой цепочки (слот-значения, entity()). */
+export const PLAN = Symbol('letopis.plan');
+const peekPlan = (x) => x !== null && typeof x === 'object' ? x[PLAN] : undefined;
+/** Конец схемы владельца, принимающий класс слота (legacy: 'Entity'-конец берёт любой HUB). */
+function findEnd(owner, slot) {
+    return owner.links.find((e) => e.classes.includes(slot.id) || (!owner.strictEnds && e.classes.includes('Entity') && slot.category === 'HUB'));
+}
+/** Значение слота: id-строка | Row | цепочка (одношаговый адрес сворачивается в id). */
+function slotValue(slotCls, v) {
+    if (typeof v === 'string')
+        return v;
+    const plan = peekPlan(v);
+    if (plan) {
+        const [head] = plan.steps;
+        if (plan.steps.length === 1 && !head.op && typeof head.filter === 'string') {
+            if (head.cls.id !== slotCls.id) {
+                throw new Error(`letopis: slot "${slotCls.id}" got a chain of class "${head.cls.id}"`);
+            }
+            return head.filter; // просто адрес db.Класс(id) — без вложенного исполнения
+        }
+        return { plan: plan.steps, mods: plan.mods };
+    }
+    if (v !== null && typeof v === 'object' && typeof v.id === 'string') {
+        return v.id; // Row / Account
+    }
+    throw new Error(`letopis: slot "${slotCls.id}" accepts an id, a Row or a chain`);
+}
+/** Узел для pivot: последний реальный шаг класса cls в ТЕКУЩЕМ читающем сегменте (до op). */
+function pivotNodeOf(steps, cls) {
+    for (let i = steps.length - 1; i >= 0; i--) {
+        const s = steps[i];
+        if (s.op)
+            return undefined; // операция закрывает паттерн — узлы до неё недоступны
+        if (s.pivotKey === undefined && s.cls.id === cls.id)
+            return s;
+    }
+    return undefined;
+}
 async function runPaths(ctx, steps, mods) {
     const q = buildRead(ctx, steps, mods, 'paths');
     const res = await runQuery(ctx, q.text, q.params, 'paths', clsOf(steps));
@@ -33,65 +73,202 @@ async function runRows(ctx, steps, mods) {
         return d != null ? { ...row, $depth: d } : row;
     });
 }
-const idOf = (t) => (typeof t === 'object' ? t.id : t);
+const NO_NODES = new Map();
 /**
- * Ленивый билдер set(): класс-вызовы довешивают связи (мутирует), await исполняет один раз.
- * run() — исполнение (сразу setOp или отложенно через батч); links — общая ссылка,
- * которую батч читает на execute().
+ * Свойство-класс (вызов = шаг/pivot; без скобок = слот). ownerSteps undefined — корень
+ * (db/batch): слот без владельца — ошибка.
  */
-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);
+function classProp(ctx, name, cls, ownerSteps, mods, batch, nodes, applySlot) {
+    const step = (filter) => {
+        const prev = ownerSteps?.[ownerSteps.length - 1];
+        // повтор LINK-класса в текущем паттерне — возврат к узлу (pivot)
+        const node = prev && cls.category === 'LINK' ? pivotNodeOf(ownerSteps, cls) : undefined;
+        if (node) {
+            const pivot = { name, cls, filter: normalizeFilter(filter), pivotKey: node.nodeKey };
+            return makeChain(ctx, [...ownerSteps, pivot], mods, batch, nodes);
+        }
+        if (prev && !prev.op)
+            resolveHop(prev.cls, cls); // ранняя проверка пути (после op — продолжение от результата)
+        const next = { name, cls, filter: normalizeFilter(filter), nodeKey: nextNodeKey() };
+        return makeChain(ctx, [...(ownerSteps ?? []), next], ownerSteps ? mods : {}, batch, nodes);
+    };
+    const slotGuard = () => {
+        if (!ownerSteps?.length || !applySlot) {
+            throw new Error(`letopis: slot "${name}" needs an owner step — start with a class call: db.Класс(…).${name}.set(…)`);
+        }
+        const owner = ownerSteps[ownerSteps.length - 1];
+        if (!findEnd(owner.cls, cls)) {
+            throw new Error(`letopis: "${cls.id}" is not a link end of "${owner.cls.id}" (Schema.links: ${owner.cls.links.map((e) => e.classes.join('|')).join(', ') || '—'})`);
+        }
+        return owner.cls;
+    };
+    return new Proxy(step, {
+        apply: (t, _self, args) => t(...args),
+        get(t, p, r) {
+            if (p === 'set') {
+                return (v) => {
+                    slotGuard();
+                    return applySlot(cls, slotValue(cls, v));
+                };
             }
-            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;
+            if (p === 'unset') {
+                return () => {
+                    const ownerCls = slotGuard();
+                    const end = findEnd(ownerCls, cls);
+                    if (ownerCls.strictEnds && !end.optional) {
+                        throw new Error(`letopis: link end "${cls.id}" of "${ownerCls.id}" is required — cannot unset`);
+                    }
+                    return applySlot(cls, null);
                 };
             }
-            registry.resolve(prop);
-            return undefined;
+            if (p === 'delete') {
+                return () => {
+                    throw new Error(`letopis: slot .delete() renamed to .unset() (0.16.0) — .${name}.unset() removes the link end`);
+                };
+            }
+            if (typeof p === 'symbol' || p === 'then' || p in Function.prototype || p === 'name' || p === 'length' || p === 'prototype') {
+                return Reflect.get(t, p, r);
+            }
+            throw new Error(`letopis: "${name}" without call is a link slot (set/unset); for navigation call ${name}(…)`);
         },
-    };
-    const proxy = new Proxy({}, handler);
-    return proxy;
+    });
 }
-function makeChain(ctx, steps, mods, batchQueue) {
+function makeChain(ctx, steps, mods, batch, nodes = NO_NODES) {
+    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, nodes);
+    };
+    const withMods = (patch) => makeChain(ctx, steps, { ...mods, ...patch }, batch, nodes);
+    /** Обновить план в батче (регистрируется на первой операции, дальше мутируется). */
+    const syncBatch = (next) => {
+        if (!batch)
+            return;
+        if (batch.entry)
+            batch.entry.steps = next;
+        else {
+            batch.entry = { steps: next };
+            batch.queue.push(batch.entry);
+        }
+    };
+    /** Операция-звено: 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, nodeKey: nextNodeKey() }]
+            : [...steps.slice(0, -1), { ...last, op }];
+        syncBatch(next);
+        return makeChain(ctx, next, {}, batch, nodes);
+    };
+    /**
+     * Слот связи: значение конца ЗАПИСЫВАЕМОЙ версии последнего шага — только после
+     * операции записи (…create(…).Класс.set(x) / …update(…).Класс.unset()): та же версия.
+     */
+    const applySlot = (slotCls, value) => {
+        const last = steps[steps.length - 1];
+        if (!last.op) {
+            throw new Error(`letopis: link slot "${slotCls.alias}" needs a write — add .create(…)/.update(…) before .${slotCls.alias}.${value === null ? 'unset()' : 'set(…)'}`);
+        }
+        if (last.op.kind !== 'create' && last.op.kind !== 'update') {
+            throw new Error(`letopis: link slot after ${last.op.kind}() — slots apply to create()/update()`);
+        }
+        if (last.extraLinks && slotCls.id in last.extraLinks) {
+            throw new Error(`letopis: duplicate link slot "${slotCls.id}" in one write`);
+        }
+        const patched = {
+            ...last,
+            extraLinks: { ...(last.extraLinks ?? {}), [slotCls.id]: value },
+        };
+        const next = [...steps.slice(0, -1), patched];
+        syncBatch(next);
+        return makeChain(ctx, next, mods, batch, nodes);
+    };
+    /** entity(x): вклейка узла/паттерна; та же переменная повторно — возврат к её узлу. */
+    const entityStep = (x) => {
+        const plan = peekPlan(x);
+        if (plan) {
+            const known = nodes.get(x);
+            if (known !== undefined) {
+                const lastX = plan.steps[plan.steps.length - 1];
+                const pivot = { name: lastX.name, cls: lastX.cls, pivotKey: known };
+                return makeChain(ctx, [...steps, pivot], mods, batch, nodes);
+            }
+            if (plan.steps.some((s) => s.op)) {
+                throw new Error('letopis: entity() takes a read pattern — a chain with operations cannot be embedded');
+            }
+            const prev = steps[steps.length - 1];
+            if (prev && !prev.op)
+                resolveHop(prev.cls, plan.steps[0].cls); // стык по правилам пути
+            const nodeKey = plan.steps[plan.steps.length - 1].nodeKey;
+            const nextNodes = new Map(nodes);
+            nextNodes.set(x, nodeKey);
+            return makeChain(ctx, [...steps, ...plan.steps], mods, batch, nextNodes);
+        }
+        if (x !== null && typeof x === 'object' && typeof x.id === 'string' && typeof x.class === 'string') {
+            const row = x;
+            const cls = ctx.registry.resolve(row.class);
+            const prev = steps[steps.length - 1];
+            if (prev && !prev.op)
+                resolveHop(prev.cls, cls);
+            const next = { name: cls.alias, cls, filter: row.id, nodeKey: nextNodeKey() };
+            return makeChain(ctx, [...steps, next], mods, batch, nodes);
+        }
+        throw new Error('letopis: entity() accepts a lazy chain or a Row');
+    };
+    /** Терминал: план (есть операции) — 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 (prop === PLAN)
+                return { steps, mods };
             if (typeof prop === 'symbol' || prop === 'then')
                 return undefined;
             switch (prop) {
+                case 'entity':
+                    return entityStep;
+                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 +288,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 +334,27 @@ function makeChain(ctx, steps, mods, batchQueue) {
                             return raw.deleted ? { ...row, $deleted: true } : row;
                         });
                     };
+                case 'create':
+                    return (data = {}) => {
+                        const last = steps[steps.length - 1];
+                        if (last && !last.op) { // после op create пишет результат — фильтр там подставит план
+                            if (last.pivotKey !== undefined) {
+                                throw new Error('letopis: create() on a pivot step — pivot returns to an existing node, use update()');
+                            }
+                            if (last.filter !== undefined && typeof last.filter !== 'string') {
+                                throw new Error(`letopis: create() takes no filter — ${last.name}(id).create(…) fixes the id, searching is update()`);
+                            }
+                        }
+                        return withOp({ kind: 'create', data, mods });
+                    };
+                case 'update':
+                    return (data = {}) => withOp({ kind: 'update', data, mods });
+                case 'set':
+                    throw new Error('letopis: set() split into create()/update() (0.16.0) — create() inserts, update() versions what the path finds');
+                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 +363,11 @@ 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':
+                    throw new Error('letopis: .link() removed (0.15.0) — use the link slot: .Класс.set(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 classProp(ctx, prop, ctx.registry.resolve(prop), steps, mods, batch, nodes, applySlot);
             }
             ctx.registry.resolve(prop); // неизвестный класс — понятная ошибка со списком
             return undefined;
@@ -181,19 +381,20 @@ 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':
                     return () => queue.length;
             }
             if (ctx.registry.has(prop)) {
-                const cls = ctx.registry.resolve(prop);
-                return (filter) => makeChain(ctx, [{ name: String(prop), cls, filter: normalizeFilter(filter) }], {}, queue);
+                return classProp(ctx, String(prop), ctx.registry.resolve(prop), undefined, {}, { queue }, NO_NODES);
             }
             ctx.registry.resolve(prop);
             return undefined;
@@ -204,6 +405,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 +415,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 +458,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':
@@ -266,9 +503,12 @@ export function makeDb(ctx, root) {
                 case 'sql':
                     return ctx.sql;
             }
+            if (prop === 'entity') {
+                // старт пути с готового паттерна/строки: db.entity(pos).…
+                return (x) => makeChain(ctx, [], {}, undefined, NO_NODES).entity(x);
+            }
             if (ctx.registry.has(prop)) {
-                const cls = ctx.registry.resolve(prop);
-                return (filter) => makeChain(ctx, [{ name: String(prop), cls, filter: normalizeFilter(filter) }], {});
+                return classProp(ctx, String(prop), ctx.registry.resolve(prop), undefined, {}, undefined, NO_NODES);
             }
             ctx.registry.resolve(prop);
             return undefined;

package/dist/index.d.ts

@@ -1,11 +1,18 @@
 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 { uuidv5, uuidv7, LETOPIS_NS } from './uuid.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,35 @@ 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';
+// генерация id (attributes.id): формула v5 открыта — id считается ДО создания
+export { uuidv5, uuidv7, LETOPIS_NS } from './uuid.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';