@ailnaf/zoddb 0.0.0-stage → 0.2.0

package/dist/db.js

@@ -0,0 +1,1063 @@
+import postgres from 'postgres';
+import { PgError, IncludeAliasError, NoRowsError, RowValidationError, UndefinedParamError, UniqueViolationError, ForeignKeyViolationError, NotNullViolationError, isPgError, uniqueColumns, } from './errors.js';
+import { compilePlanMappers, isSqlFragment } from './table.js';
+import { compileCursor, compileOrderBy, compileWhere } from './filter.js';
+import { aggregateImpl } from './aggregate.js';
+import { resolveRelationColumn } from './relations.js';
+const ISOLATION_LEVELS = ['read committed', 'repeatable read', 'serializable'];
+export function many(table, opts) {
+    return opts ? { _kind: 'many', table, ...opts } : { _rel: 'many', table };
+}
+export function one(table, opts) {
+    return opts ? { _kind: 'one', table, ...opts } : { _rel: 'one', table };
+}
+function emitQuery(ctx, event) {
+    try {
+        ctx.hooks?.onQuery?.(event);
+    }
+    catch { /* 日志不能反噬业务 */ }
+    if (event.slow) {
+        try {
+            ctx.hooks?.onSlowQuery?.(event);
+        }
+        catch { /* 同上 */ }
+    }
+}
+async function trackQuery(ctx, meta, fn, countRows) {
+    const start = performance.now();
+    try {
+        const result = await fn();
+        const durationMs = performance.now() - start;
+        emitQuery(ctx, {
+            ...meta,
+            durationMs,
+            slow: ctx.slowQueryMs !== undefined && durationMs >= ctx.slowQueryMs,
+            replica: ctx.onReplica === true,
+            rows: countRows ? countRows(result) : (Array.isArray(result) ? result.length : undefined),
+        });
+        return result;
+    }
+    catch (error) {
+        const durationMs = performance.now() - start;
+        emitQuery(ctx, {
+            ...meta,
+            durationMs,
+            error,
+            slow: ctx.slowQueryMs !== undefined && durationMs >= ctx.slowQueryMs,
+            replica: ctx.onReplica === true,
+        });
+        throw error;
+    }
+}
+async function exec(ctx, text, params = [], meta = { operation: 'query' }) {
+    return trackQuery(ctx, { ...meta, sql: text, params }, () => ctx.raw.unsafe(text, params));
+}
+const readCtx = (ctx) => ctx.replica ? { ...ctx, raw: ctx.replica, onReplica: true } : ctx;
+const quoteIdent = (s) => `"${s.replace(/"/g, '""')}"`;
+/** 顶层用 begin；已在事务里时用 savepoint（postgres.js 的 TransactionSql 没有 begin） */
+function beginOrSavepoint(conn, cb) {
+    const c = conn;
+    if (typeof c.begin === 'function')
+        return c.begin.call(conn, cb);
+    if (typeof c.savepoint === 'function')
+        return c.savepoint.call(conn, cb);
+    throw new Error('create/seed: 当前连接既不支持 begin 也不支持 savepoint');
+}
+const isSelectFragment = (v) => typeof v === 'object' && v !== null && v._tag === 'select';
+function assertParams(params) {
+    for (let i = 0; i < params.length; i++) {
+        const p = params[i];
+        if (p === undefined)
+            throw new UndefinedParamError(i);
+        if (Array.isArray(p) && p.some(v => v === undefined))
+            throw new UndefinedParamError(i, 'array-element');
+    }
+}
+function mapError(e, table) {
+    if (!isPgError(e))
+        return e;
+    const cols = table ? table.__plan.map(p => p.dbKey) : [];
+    switch (e.code) {
+        case '23505':
+            return new UniqueViolationError(e, uniqueColumns(e.constraint_name, table?.name ?? e.table_name, cols));
+        case '23502':
+            return new NotNullViolationError(e);
+        case '23503':
+            return new ForeignKeyViolationError(e);
+        default:
+            return new PgError(e);
+    }
+}
+function readInclude(v, spec, validate, index, alias = '') {
+    if (spec._rel === 'one') {
+        if (v === null || v === undefined)
+            return null;
+        return mapRow(v, spec.table, undefined, validate, index);
+    }
+    if (v === null || v === undefined)
+        return [];
+    if (!Array.isArray(v))
+        throw new RowValidationError(spec.table.name, index, [], alias);
+    return v.map(el => mapRow(el, spec.table, undefined, validate, index));
+}
+function mapRow(row, table, include, validate, index) {
+    const out = validate ? table.__mapValid(row, index) : table.__mapFast(row);
+    if (include) {
+        for (const key of Object.keys(include)) {
+            if (validate && !(key in row))
+                throw new IncludeAliasError(table.name, key, index);
+            out[key] = readInclude(row[key], include[key], validate, index, key);
+        }
+    }
+    return out;
+}
+const dbKeyOf = (table, key) => table.__plan.find(p => p.outKey === key)?.dbKey ?? key;
+function buildWhere(table, where, offset = 0, relations = []) {
+    if (isSqlFragment(where)) {
+        let text = '';
+        for (let i = 0; i < where.strings.length; i++) {
+            text += where.strings[i];
+            if (i < where.params.length)
+                text += `$${offset + i + 1}`;
+        }
+        return { text, params: [...where.params] };
+    }
+    return compileWhere(table, where, offset, relations);
+}
+function rawTextFragment(ctx, text) {
+    const strings = [text];
+    strings.raw = [text];
+    return ctx.raw(strings);
+}
+function makeSelect(ctx, table, keys, alias) {
+    for (const k of keys) {
+        if (!table.__plan.some(p => p.outKey === k))
+            throw new Error(`select: 未知列 ${table.name}.${k}`);
+    }
+    const prefix = alias ? `${quoteIdent(alias)}.` : '';
+    const text = keys.map(k => prefix + quoteIdent(dbKeyOf(table, k))).join(', ');
+    const plan = table.__plan.filter(p => keys.includes(p.outKey));
+    const compiled = compilePlanMappers(table.name, plan);
+    const parsers = plan.map(p => p.parse);
+    return {
+        _tag: 'select',
+        table,
+        keys,
+        __fragment: rawTextFragment(ctx, text),
+        __text: text,
+        __mapFast: compiled.fast,
+        __mapValid: (row, i) => compiled.valid(row, i, parsers, table.name, RowValidationError),
+        $row: undefined,
+        as: alias2 => makeSelect(ctx, table, keys, alias2),
+        toSQL: () => text,
+    };
+}
+// ---------------------------------------------------------------- Query
+export class Query {
+    #pending;
+    #ctx;
+    #factory;
+    #sql;
+    #params;
+    constructor(ctx, factory, sql = '', params = []) {
+        this.#ctx = ctx;
+        this.#factory = factory;
+        this.#sql = sql;
+        this.#params = params;
+    }
+    pending() {
+        return (this.#pending ??= this.#factory());
+    }
+    async run(table) {
+        try {
+            return await trackQuery(this.#ctx, { sql: this.#sql, params: this.#params, operation: 'sql' }, () => this.pending(), result => result.length);
+        }
+        catch (e) {
+            throw mapError(e, table);
+        }
+    }
+    then(onfulfilled, onrejected) {
+        return this.run().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.run().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.run().finally(onfinally);
+    }
+    /** 原始行：不映射、不校验（逃生舱） */
+    execute() {
+        return this.run();
+    }
+    async rows(arg, opts) {
+        if (arg._tag === 'select') {
+            const rows = (await this.run(arg.table));
+            return rows.map((row, i) => this.#ctx.shouldValidate ? arg.__mapValid(row, i) : arg.__mapFast(row));
+        }
+        const rows = (await this.run(arg));
+        return rows.map((row, i) => mapRow(row, arg, opts?.include, this.#ctx.shouldValidate, i));
+    }
+    async one(arg, opts) {
+        const rows = await this.rows(arg, opts);
+        if (rows.length === 0)
+            throw new NoRowsError(arg._tag === 'select' ? arg.table.name : arg.name);
+        return rows[0];
+    }
+    async maybeOne(arg, opts) {
+        const rows = await this.rows(arg, opts);
+        return rows[0] ?? null;
+    }
+}
+async function insertImpl(ctx, table, values) {
+    const parsed = ctx.shouldValidate ? table.insertSchema.parse(values) : values;
+    const entries = Object.entries(parsed).filter(([, v]) => v !== undefined);
+    const text = entries.length === 0
+        ? `insert into ${quoteIdent(table.name)} default values returning *`
+        : `insert into ${quoteIdent(table.name)} (${entries.map(([k]) => quoteIdent(dbKeyOf(table, k))).join(', ')}) `
+            + `values (${entries.map((_, i) => `$${i + 1}`).join(', ')}) returning *`;
+    const params = entries.map(([, v]) => v);
+    try {
+        const res = await exec(ctx, text, params, { operation: 'insert', table: table.name });
+        return res.map((row, i) => mapRow(row, table, undefined, ctx.shouldValidate, i));
+    }
+    catch (e) {
+        throw mapError(e, table);
+    }
+}
+async function insertManyImpl(ctx, table, values, chunkSize = 1000) {
+    if (values.length === 0)
+        return [];
+    const parsed = values.map(v => ctx.shouldValidate ? table.insertSchema.parse(v) : v);
+    const first = parsed[0];
+    const keys = Object.keys(first).filter(k => first[k] !== undefined);
+    const width = keys.length;
+    const prefix = `insert into ${quoteIdent(table.name)} (${keys.map(k => quoteIdent(dbKeyOf(table, k))).join(', ')}) values `;
+    const out = [];
+    for (let start = 0; start < parsed.length; start += chunkSize) {
+        const chunk = parsed.slice(start, start + chunkSize);
+        const params = new Array(chunk.length * width);
+        let tuples = '';
+        let at = 0;
+        for (let r = 0; r < chunk.length; r++) {
+            const row = chunk[r];
+            if (r > 0)
+                tuples += ', ';
+            tuples += '(';
+            let c = 0;
+            // 单趟：校验列序/列集合 与 收集参数合并，避免额外分配
+            for (const k in row) {
+                const v = row[k];
+                if (v === undefined)
+                    continue;
+                if (k !== keys[c]) {
+                    throw new Error(`insertMany 要求统一列集合：第 ${start + r} 行出现列 "${k}"（期望 "${keys[c]}"）`);
+                }
+                if (c > 0)
+                    tuples += ', ';
+                params[at] = v;
+                at += 1;
+                tuples += `$${at}`;
+                c += 1;
+            }
+            if (c !== width)
+                throw new Error(`insertMany 要求统一列集合：第 ${start + r} 行的列数与首行不同`);
+            tuples += ')';
+        }
+        try {
+            const res = await exec(ctx, `${prefix}${tuples} returning *`, params, { operation: 'insertMany', table: table.name });
+            for (const row of res) {
+                out.push(mapRow(row, table, undefined, ctx.shouldValidate, out.length));
+            }
+        }
+        catch (e) {
+            throw mapError(e, table);
+        }
+    }
+    return out;
+}
+function linkPrimaryKey(def, operation) {
+    const pk = def.table.__plan.find(p => p.pk);
+    if (!pk)
+        throw new Error(`${operation}: ${def.table.name} 没有主键`);
+    return pk;
+}
+function parseLinkSpec(value, allowed, operation) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`${operation} 需要对象`);
+    }
+    const spec = value;
+    for (const key of Object.keys(spec)) {
+        if (!allowed.includes(key)) {
+            throw new Error(`${operation} 只支持 ${allowed.join('/')}（收到 ${key}）`);
+        }
+    }
+    return spec;
+}
+function linkIds(def, refs, operation) {
+    if (!Array.isArray(refs))
+        throw new Error(`${operation} 必须是数组`);
+    const pk = linkPrimaryKey(def, operation);
+    const ids = [];
+    const seen = new Set();
+    for (const ref of refs) {
+        if (typeof ref !== 'object' || ref === null || Array.isArray(ref)) {
+            throw new Error(`${operation} 的元素必须是对象`);
+        }
+        const id = ref[pk.outKey];
+        if (id === undefined || id === null)
+            throw new Error(`${operation} 需要 ${def.table.name}.${pk.outKey}`);
+        if (!seen.has(id)) {
+            seen.add(id);
+            ids.push(id);
+        }
+    }
+    return ids;
+}
+async function loadLinkTargets(ctx, def, ids, operation, requireAll) {
+    if (ids.length === 0)
+        return [];
+    const pk = linkPrimaryKey(def, operation);
+    const rows = await findManyImpl(ctx, def.table, {
+        where: { [pk.outKey]: { in: ids } },
+    });
+    const byId = new Map();
+    for (const row of rows)
+        byId.set(row[pk.outKey], row);
+    const out = [];
+    for (const id of ids) {
+        const row = byId.get(id);
+        if (!row) {
+            if (requireAll)
+                throw new Error(`${operation}: 找不到 ${def.table.name}.${String(id)}`);
+            continue;
+        }
+        out.push(row);
+    }
+    return out;
+}
+async function insertLinkRows(ctx, def, sourceValue, targets, operation) {
+    if (targets.length === 0)
+        return;
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const throughFrom = resolveRelationColumn(def.through.from);
+    const throughTo = resolveRelationColumn(def.through.to);
+    if (sourceValue === undefined || sourceValue === null) {
+        throw new Error(`${operation}: ${from.table.name}.${from.outKey} 不能为空`);
+    }
+    for (const target of targets) {
+        const targetValue = target[to.outKey];
+        if (targetValue === undefined || targetValue === null) {
+            throw new Error(`${operation}: ${def.table.name}.${to.outKey} 不能为空`);
+        }
+        const text = `insert into ${quoteIdent(def.through.table.name)}`
+            + ` (${quoteIdent(throughFrom.dbKey)}, ${quoteIdent(throughTo.dbKey)})`
+            + ' values ($1, $2) on conflict do nothing';
+        await exec(ctx, text, [sourceValue, targetValue], {
+            operation: 'insert',
+            table: def.through.table.name,
+        });
+    }
+}
+async function deleteLinkRows(ctx, def, sourceValue, targetValues, operation) {
+    if (targetValues !== undefined && targetValues.length === 0)
+        return;
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const throughFrom = resolveRelationColumn(def.through.from);
+    const throughTo = resolveRelationColumn(def.through.to);
+    if (sourceValue === undefined || sourceValue === null) {
+        throw new Error(`${operation}: ${from.table.name}.${from.outKey} 不能为空`);
+    }
+    let text = `delete from ${quoteIdent(def.through.table.name)}`
+        + ` where ${quoteIdent(throughFrom.dbKey)} = $1`;
+    const params = [sourceValue];
+    if (targetValues !== undefined) {
+        text += ` and ${quoteIdent(throughTo.dbKey)} in (${targetValues.map((_, i) => `$${i + 2}`).join(', ')})`;
+        params.push(...targetValues);
+    }
+    await exec(ctx, text, params, { operation: 'delete', table: def.through.table.name });
+}
+async function applyLinkWrite(ctx, parent, table, key, def, value) {
+    const operation = `update ${table.name}.${key}`;
+    const spec = parseLinkSpec(value, ['connect', 'disconnect', 'set'], operation);
+    if (spec.connect === undefined && spec.disconnect === undefined && spec.set === undefined) {
+        throw new Error(`${operation} 需要 connect/disconnect/set 之一`);
+    }
+    if (spec.set !== undefined && (spec.connect !== undefined || spec.disconnect !== undefined)) {
+        throw new Error(`${operation} 的 set 不能与 connect/disconnect 同时使用`);
+    }
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const sourceValue = parent[from.outKey];
+    if (sourceValue === undefined || sourceValue === null) {
+        throw new Error(`${operation}: ${table.name}.${from.outKey} 不能为空`);
+    }
+    if (spec.set !== undefined) {
+        const ids = linkIds(def, spec.set, `${operation}.set`);
+        const targets = await loadLinkTargets(ctx, def, ids, `${operation}.set`, true);
+        await deleteLinkRows(ctx, def, sourceValue, undefined, operation);
+        await insertLinkRows(ctx, def, sourceValue, targets, operation);
+        return;
+    }
+    if (spec.disconnect !== undefined) {
+        const ids = linkIds(def, spec.disconnect, `${operation}.disconnect`);
+        const found = await loadLinkTargets(ctx, def, ids, `${operation}.disconnect`, false);
+        const targetValues = found.map(target => target[to.outKey]).filter(v => v !== undefined && v !== null);
+        await deleteLinkRows(ctx, def, sourceValue, targetValues, `${operation}.disconnect`);
+    }
+    if (spec.connect !== undefined) {
+        const ids = linkIds(def, spec.connect, `${operation}.connect`);
+        const targets = await loadLinkTargets(ctx, def, ids, `${operation}.connect`, true);
+        await insertLinkRows(ctx, def, sourceValue, targets, `${operation}.connect`);
+    }
+}
+async function createImpl(ctx, table, input) {
+    const rels = ctx.relations.find(r => r.table === table);
+    const columns = {};
+    const nested = [];
+    for (const [k, v] of Object.entries(input)) {
+        if (table.__plan.some(p => p.outKey === k))
+            columns[k] = v;
+        else if (rels?.map[k]) {
+            const def = rels.map[k];
+            if (def._write === false && !def.through)
+                throw new Error(`create: ${table.name}.${k} 是只读关系，不支持 nested create`);
+            nested.push({ key: k, def, value: v });
+        }
+        else
+            throw new Error(`create: 未知字段 ${table.name}.${k}`);
+    }
+    if (nested.length > 0 && table.__primaryKey.length > 0) {
+        throw new Error(`create: ${table.name} 使用复合主键，暂不支持 nested create 父行`);
+    }
+    return beginOrSavepoint(ctx.raw, async (txSql) => {
+        const tx = {
+            raw: txSql,
+            validate: ctx.validate,
+            shouldValidate: ctx.shouldValidate,
+            relations: ctx.relations,
+        };
+        const inserted = await insertImpl(tx, table, columns);
+        let parent = inserted[0];
+        const parentPk = table.__plan.find(p => p.pk);
+        for (const { key, def, value } of nested) {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                throw new Error(`create: ${table.name}.${key} 需要 { create } 或 { connect }`);
+            }
+            const spec = value;
+            const from = resolveRelationColumn(def.from);
+            const to = resolveRelationColumn(def.to);
+            const childPk = def.table.__plan.find(p => p.pk);
+            if (def.through) {
+                const linkSpec = parseLinkSpec(value, ['connect'], `create ${table.name}.${key} M2M through`);
+                if (linkSpec.connect === undefined) {
+                    parent[key] = [];
+                    continue;
+                }
+                const ids = linkIds(def, linkSpec.connect, `create ${table.name}.${key}.connect`);
+                const targets = await loadLinkTargets(tx, def, ids, `create ${table.name}.${key}.connect`, true);
+                const sourceValue = parent[from.outKey];
+                await insertLinkRows(tx, def, sourceValue, targets, `create ${table.name}.${key}.connect`);
+                parent[key] = targets;
+                continue;
+            }
+            if (def._kind === 'many') {
+                const out = [];
+                if (spec.create) {
+                    const childValues = spec.create.map(v => ({ ...v, [to.outKey]: parent[from.outKey] }));
+                    out.push(...await insertManyImpl(tx, def.table, childValues));
+                }
+                if (spec.connect !== undefined) {
+                    if (!Array.isArray(spec.connect))
+                        throw new Error(`create: ${table.name}.${key} 的 connect 必须是数组`);
+                    if (!childPk)
+                        throw new Error(`create connect: ${def.table.name} 没有主键`);
+                    for (const v of spec.connect) {
+                        const id = v[childPk.outKey];
+                        if (id === undefined || id === null)
+                            throw new Error(`create connect: 需要 ${def.table.name}.${childPk.outKey}`);
+                        const rows = await updateImpl(tx, def.table, { [to.outKey]: parent[from.outKey] }, { [childPk.outKey]: id });
+                        if (rows.length === 0)
+                            throw new Error(`create connect: 找不到 ${def.table.name}.${String(id)}`);
+                        out.push(...rows);
+                    }
+                }
+                parent[key] = out;
+                continue;
+            }
+            if (spec.create)
+                throw new Error(`create: ${table.name}.${key} 是 one 关系，只支持 connect`);
+            if (spec.connect === undefined) {
+                parent[key] = null;
+                continue;
+            }
+            if (typeof spec.connect !== 'object' || Array.isArray(spec.connect))
+                throw new Error(`create: ${table.name}.${key} 的 connect 必须是对象`);
+            if (!childPk || !parentPk)
+                throw new Error(`create connect: ${def.table.name} 或 ${table.name} 没有主键`);
+            const connect = spec.connect;
+            const id = connect[childPk.outKey];
+            if (id === undefined || id === null)
+                throw new Error(`create connect: 需要 ${def.table.name}.${childPk.outKey}`);
+            const target = await findOneImpl(tx, def.table, { where: { [childPk.outKey]: id } });
+            if (!target)
+                throw new Error(`create connect: 找不到 ${def.table.name}.${String(id)}`);
+            const rows = await updateImpl(tx, table, { [from.outKey]: target[to.outKey] }, { [parentPk.outKey]: parent[parentPk.outKey] });
+            if (rows.length === 0)
+                throw new Error(`create connect: 更新 ${table.name} 失败`);
+            parent = rows[0];
+            parent[key] = target;
+        }
+        return parent;
+    });
+}
+async function seedImpl(ctx, table, rows, opts) {
+    if (rows.length === 0)
+        return [];
+    if (!opts.conflict || opts.conflict.length === 0)
+        throw new Error('seed: conflict 不能为空');
+    // seed 默认只插入缺失行；要覆盖已有行必须显式传 update
+    const upsertOpts = { conflict: opts.conflict, update: opts.update ?? [] };
+    return beginOrSavepoint(ctx.raw, async (txSql) => {
+        const tx = { ...ctx, raw: txSql };
+        const out = [];
+        for (const row of rows)
+            out.push(...await upsertImpl(tx, table, row, upsertOpts));
+        return out;
+    });
+}
+async function updateColumnsImpl(ctx, table, values, where) {
+    const parsed = ctx.shouldValidate ? table.updateSchema.parse(values) : values;
+    const entries = Object.entries(parsed).filter(([, v]) => v !== undefined);
+    if (entries.length === 0)
+        throw new Error('update: 没有要更新的列');
+    const sets = entries.map(([k], i) => `${quoteIdent(dbKeyOf(table, k))} = $${i + 1}`);
+    const w = buildWhere(table, where, entries.length);
+    if (!w.text)
+        throw new Error('where 不能为空（拒绝全表操作）');
+    const text = `update ${quoteIdent(table.name)} set ${sets.join(', ')} where ${w.text} returning *`;
+    const params = [...entries.map(([, v]) => v), ...w.params];
+    try {
+        const res = await exec(ctx, text, params, { operation: 'insert', table: table.name });
+        return res.map((row, i) => mapRow(row, table, undefined, ctx.shouldValidate, i));
+    }
+    catch (e) {
+        throw mapError(e, table);
+    }
+}
+async function updateImpl(ctx, table, values, where) {
+    const rels = ctx.relations.find(r => r.table === table);
+    const columns = {};
+    const links = [];
+    const unknown = [];
+    for (const [k, v] of Object.entries(values)) {
+        if (v === undefined)
+            continue;
+        if (table.__plan.some(p => p.outKey === k)) {
+            columns[k] = v;
+            continue;
+        }
+        const def = rels?.map[k];
+        if (def?.through) {
+            links.push({ key: k, def, value: v });
+            continue;
+        }
+        if (def)
+            throw new Error(`update: ${table.name}.${k} 不支持关系写入（只有 M2M through 支持）`);
+        unknown.push(k);
+    }
+    // 保留既有 update 的 ZodError 语义：未知列先交给严格 schema 报错。
+    if (unknown.length > 0) {
+        if (ctx.shouldValidate)
+            table.updateSchema.parse(values);
+        throw new Error(`update: 未知字段 ${table.name}.${unknown[0]}`);
+    }
+    if (links.length === 0)
+        return updateColumnsImpl(ctx, table, columns, where);
+    return beginOrSavepoint(ctx.raw, async (txSql) => {
+        const tx = { ...ctx, raw: txSql };
+        let rows;
+        if (Object.keys(columns).length > 0) {
+            rows = await updateColumnsImpl(tx, table, columns, where);
+        }
+        else {
+            rows = await findManyImpl(tx, table, { where: where, limit: 2 });
+        }
+        if (rows.length !== 1) {
+            throw new Error(`update: M2M 关系写入要求 where 命中恰好 1 行（命中 ${rows.length} 行）`);
+        }
+        const parent = rows[0];
+        for (const { key, def, value } of links) {
+            await applyLinkWrite(tx, parent, table, key, def, value);
+        }
+        return rows;
+    });
+}
+async function deleteImpl(ctx, table, where) {
+    const w = buildWhere(table, where);
+    if (!w.text)
+        throw new Error('where 不能为空（拒绝全表操作）');
+    try {
+        const res = await exec(ctx, `delete from ${quoteIdent(table.name)} where ${w.text}`, w.params, { operation: 'delete', table: table.name });
+        return res.count;
+    }
+    catch (e) {
+        throw mapError(e, table);
+    }
+}
+async function upsertImpl(ctx, table, values, opts) {
+    const parsed = ctx.shouldValidate ? table.insertSchema.parse(values) : values;
+    const entries = Object.entries(parsed).filter(([, v]) => v !== undefined);
+    if (entries.length === 0)
+        throw new Error('upsert: 没有要写入的列');
+    const dbKeyStrict = (k, kind) => {
+        const plan = table.__plan.find(p => p.outKey === k);
+        if (!plan)
+            throw new Error(`upsert: 未知${kind} ${table.name}.${k}`);
+        return plan.dbKey;
+    };
+    const conflict = opts.conflict.map(k => dbKeyStrict(k, '冲突列'));
+    const updateKeys = opts.update ?? Object.keys(parsed).filter(k => {
+        if (opts.conflict.includes(k))
+            return false;
+        return !table.__plan.find(p => p.outKey === k)?.pk; // 默认不覆盖主键
+    });
+    const updateCols = updateKeys.filter(k => parsed[k] !== undefined).map(k => dbKeyStrict(k, '更新列'));
+    const text = `insert into ${quoteIdent(table.name)} (${entries.map(([k]) => quoteIdent(dbKeyOf(table, k))).join(', ')}) `
+        + `values (${entries.map((_, i) => `$${i + 1}`).join(', ')}) `
+        + `on conflict (${conflict.map(quoteIdent).join(', ')}) `
+        + (updateCols.length === 0
+            ? 'do nothing'
+            : `do update set ${updateCols.map(c => `${quoteIdent(c)} = excluded.${quoteIdent(c)}`).join(', ')}`)
+        + ' returning *';
+    try {
+        const res = await exec(ctx, text, entries.map(([, v]) => v), { operation: 'upsert', table: table.name });
+        return res.map((row, i) => mapRow(row, table, undefined, ctx.shouldValidate, i));
+    }
+    catch (e) {
+        throw mapError(e, table);
+    }
+}
+async function countImpl(ctx, table, where) {
+    const w = where === undefined ? undefined : buildWhere(table, where, 0, ctx.relations);
+    const text = `select count(*)::int as n from ${quoteIdent(table.name)}` + (w ? ` where ${w.text}` : '');
+    const rows = await exec(ctx, text, w?.params ?? [], { operation: 'count', table: table.name });
+    return rows[0]?.n ?? 0;
+}
+const AGGREGATE_NUMERIC = /^(int|int2|int4|int8|smallint|integer|bigint|numeric|decimal|real|double|float)/;
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function parseAggregate(table, raw) {
+    if (!isPlainObject(raw))
+        throw new Error(`with: ${table.name}.aggregate 必须是对象`);
+    const allowed = new Set(['count', 'sum', 'max']);
+    for (const key of Object.keys(raw)) {
+        if (!allowed.has(key))
+            throw new Error(`with: ${table.name}.aggregate 不支持 ${key}`);
+    }
+    if (raw.count !== undefined && raw.count !== true)
+        throw new Error(`with: ${table.name}.aggregate.count 必须是 true`);
+    const count = raw.count === true;
+    const parseColumns = (name) => {
+        const value = raw[name];
+        if (value === undefined)
+            return [];
+        if (!isPlainObject(value))
+            throw new Error(`with: ${table.name}.aggregate.${name} 必须是对象`);
+        const result = [];
+        for (const [outKey, enabled] of Object.entries(value)) {
+            if (enabled !== true)
+                throw new Error(`with: ${table.name}.aggregate.${name}.${outKey} 必须是 true`);
+            const plan = table.__plan.find(p => p.outKey === outKey);
+            if (!plan)
+                throw new Error(`with: ${table.name}.aggregate.${name} 未知列 ${outKey}`);
+            if (name === 'sum' && !AGGREGATE_NUMERIC.test(plan.sqlType)) {
+                throw new Error(`with: ${table.name}.aggregate.sum.${outKey} 必须是数值列（${plan.sqlType}）`);
+            }
+            result.push({ outKey, dbKey: plan.dbKey, parse: value => plan.parse.parse(value) });
+        }
+        return result;
+    };
+    const sum = parseColumns('sum');
+    const max = parseColumns('max');
+    if (!count && sum.length === 0 && max.length === 0) {
+        throw new Error(`with: ${table.name}.aggregate 至少需要 count/sum/max 之一`);
+    }
+    return { count, sum, max };
+}
+const MAX_WITH_DEPTH = 3;
+function resolveWith(ctx, table, withMap, depth = 1) {
+    if (depth > MAX_WITH_DEPTH)
+        throw new Error(`with: 关系加载超过最大深度 ${MAX_WITH_DEPTH}`);
+    const entries = Object.entries(withMap).filter(([, v]) => v !== undefined && v !== false);
+    if (entries.length === 0)
+        return [];
+    const rels = ctx.relations.find(r => r.table === table);
+    if (!rels)
+        throw new Error(`with: 表 ${table.name} 没有定义 relations()`);
+    return entries.map(([key, enabled]) => {
+        const def = rels.map[key];
+        if (!def)
+            throw new Error(`with: 未知关系 ${table.name}.${key}`);
+        if (enabled === true)
+            return { key, def };
+        if (typeof enabled !== 'object' || enabled === null || Array.isArray(enabled)) {
+            throw new Error(`with: ${table.name}.${key} 只支持 true/false 或关系选项对象`);
+        }
+        const opts = enabled;
+        const allowed = new Set(['where', 'orderBy', 'limit', 'offset', 'with', 'aggregate']);
+        for (const k of Object.keys(opts)) {
+            if (!allowed.has(k))
+                throw new Error(`with: ${table.name}.${key} 不支持选项 ${k}`);
+        }
+        if (Object.keys(opts).length === 0)
+            throw new Error(`with: ${table.name}.${key} 需要 where/orderBy/limit/offset/with/aggregate 之一`);
+        if (def.through && (opts.where !== undefined || opts.orderBy !== undefined || opts.limit !== undefined || opts.offset !== undefined)) {
+            throw new Error(`with: M2M through 关系 ${table.name}.${key} 暂不支持 where/orderBy/limit/offset`);
+        }
+        if (opts.where !== undefined && (typeof opts.where !== 'object' || opts.where === null || Array.isArray(opts.where))) {
+            throw new Error(`with: ${table.name}.${key}.where 必须是对象`);
+        }
+        if (opts.with !== undefined && (typeof opts.with !== 'object' || opts.with === null || Array.isArray(opts.with))) {
+            throw new Error(`with: ${table.name}.${key}.with 必须是对象`);
+        }
+        const aggregate = opts.aggregate === undefined ? undefined : parseAggregate(def.table, opts.aggregate);
+        if (aggregate && table.__plan.some(p => p.outKey === `${key}Aggregate`)) {
+            throw new Error(`with: 聚合别名 ${key}Aggregate 与 ${table.name} 的真实列冲突`);
+        }
+        return {
+            key,
+            def,
+            where: opts.where,
+            orderBy: opts.orderBy,
+            limit: opts.limit,
+            offset: opts.offset,
+            with: opts.with,
+            aggregate,
+        };
+    });
+}
+async function attachThroughRelation(ctx, rows, key, def, through, nested, depth = 1) {
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const throughFrom = resolveRelationColumn(through.from);
+    const throughTo = resolveRelationColumn(through.to);
+    const values = [...new Set(rows.map(r => r[from.outKey]).filter(v => v !== null && v !== undefined))];
+    const links = new Map();
+    if (values.length > 0) {
+        const linkRows = await exec(ctx, `select ${quoteIdent(throughFrom.dbKey)}, ${quoteIdent(throughTo.dbKey)} from ${quoteIdent(through.table.name)} where ${quoteIdent(throughFrom.dbKey)} = any($1)`, [values], { operation: 'with', table: through.table.name });
+        for (const row of linkRows) {
+            const parent = row[throughFrom.dbKey];
+            const target = row[throughTo.dbKey];
+            if (parent === null || parent === undefined || target === null || target === undefined)
+                continue;
+            const bucket = links.get(parent);
+            if (bucket)
+                bucket.push(target);
+            else
+                links.set(parent, [target]);
+        }
+    }
+    const targetValues = [...new Set([...links.values()].flat())];
+    let children = [];
+    if (targetValues.length > 0) {
+        const childRows = await exec(ctx, `select * from ${quoteIdent(def.table.name)} where ${quoteIdent(to.dbKey)} = any($1)`, [targetValues], { operation: 'with', table: def.table.name });
+        children = childRows.map((row, i) => mapRow(row, def.table, undefined, ctx.shouldValidate, i));
+    }
+    const byTarget = new Map();
+    for (const child of children)
+        byTarget.set(child[to.outKey], child);
+    for (const row of rows) {
+        const ids = links.get(row[from.outKey]);
+        const bucket = ids
+            ? [...new Set(ids)].map(id => byTarget.get(id)).filter((child) => child !== undefined)
+            : [];
+        row[key] = bucket;
+    }
+    if (nested.length > 0 && children.length > 0)
+        await attachRelations(ctx, children, nested, depth);
+}
+function validateWithNumber(name, value) {
+    if (value === undefined)
+        return;
+    if (!Number.isInteger(value) || value < 0)
+        throw new Error(`with: ${name} 必须是非负整数`);
+}
+async function attachAggregate(ctx, rows, key, def, aggregate, where) {
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const through = def.through;
+    const values = [...new Set(rows.map(r => r[from.outKey]).filter(v => v !== null && v !== undefined))];
+    const targetAliasName = '__zd_agg_target';
+    const targetAlias = quoteIdent(targetAliasName);
+    let parentRef;
+    let fromClause;
+    if (through) {
+        const throughFrom = resolveRelationColumn(through.from);
+        const throughTo = resolveRelationColumn(through.to);
+        const throughAlias = quoteIdent('__zd_agg_through');
+        parentRef = `${throughAlias}.${quoteIdent(throughFrom.dbKey)}`;
+        fromClause = `from ${quoteIdent(through.table.name)} as ${throughAlias}`
+            + ` join ${quoteIdent(def.table.name)} as ${targetAlias}`
+            + ` on ${targetAlias}.${quoteIdent(to.dbKey)} = ${throughAlias}.${quoteIdent(throughTo.dbKey)}`;
+    }
+    else {
+        parentRef = `${targetAlias}.${quoteIdent(to.dbKey)}`;
+        fromClause = `from ${quoteIdent(def.table.name)} as ${targetAlias}`;
+    }
+    const sumFields = aggregate.sum.map((p, i) => ({ ...p, alias: `__zd_sum_${i}` }));
+    const maxFields = aggregate.max.map((p, i) => ({ ...p, alias: `__zd_max_${i}` }));
+    const select = [`${parentRef} as "__zd_parent"`];
+    if (aggregate.count)
+        select.push('count(*)::int as "__zd_count"');
+    for (const p of sumFields)
+        select.push(`sum(${targetAlias}.${quoteIdent(p.dbKey)})::float8 as ${quoteIdent(p.alias)}`);
+    for (const p of maxFields)
+        select.push(`max(${targetAlias}.${quoteIdent(p.dbKey)}) as ${quoteIdent(p.alias)}`);
+    const wherePart = where === undefined
+        ? { text: '', params: [] }
+        : compileWhere(def.table, where, 1, [], targetAliasName);
+    const params = [values, ...wherePart.params];
+    const predicate = wherePart.text ? ` and (${wherePart.text})` : '';
+    const text = `select ${select.join(', ')} ${fromClause}`
+        + ` where ${parentRef} = any($1)${predicate}`
+        + ` group by ${parentRef}`;
+    const aggregateRows = values.length === 0
+        ? []
+        : await exec(ctx, text, params, { operation: 'with', table: def.table.name });
+    const byParent = new Map();
+    for (const row of aggregateRows) {
+        const parent = row.__zd_parent;
+        if (parent !== null && parent !== undefined)
+            byParent.set(parent, row);
+    }
+    for (const row of rows) {
+        const parent = row[from.outKey];
+        const raw = parent === null || parent === undefined ? undefined : byParent.get(parent);
+        const result = {};
+        if (aggregate.count)
+            result.count = Number(raw?.__zd_count ?? 0);
+        if (sumFields.length > 0) {
+            result.sum = Object.fromEntries(sumFields.map(p => [p.outKey, raw?.[p.alias] == null ? null : Number(raw[p.alias])]));
+        }
+        if (maxFields.length > 0) {
+            result.max = Object.fromEntries(maxFields.map(p => [p.outKey, raw?.[p.alias] == null ? null : p.parse(raw[p.alias])]));
+        }
+        row[`${key}Aggregate`] = result;
+    }
+}
+async function attachRelations(ctx, rows, resolved, depth = 1) {
+    for (const { key, def, where, orderBy, limit, offset, with: nestedInput, aggregate } of resolved) {
+        const nested = nestedInput !== undefined ? resolveWith(ctx, def.table, nestedInput, depth + 1) : [];
+        if (def.through) {
+            await attachThroughRelation(ctx, rows, key, def, def.through, nested, depth + 1);
+            if (aggregate)
+                await attachAggregate(ctx, rows, key, def, aggregate, where);
+            continue;
+        }
+        const from = resolveRelationColumn(def.from);
+        const to = resolveRelationColumn(def.to);
+        if (def._kind === 'one' && (limit !== undefined || offset !== undefined)) {
+            throw new Error(`with: one 关系 ${def.table.name}.${key} 不支持 limit/offset`);
+        }
+        if (offset !== undefined && limit === undefined) {
+            throw new Error(`with: ${def.table.name}.${key} 使用 offset 时必须同时提供 limit`);
+        }
+        validateWithNumber(`${def.table.name}.${key}.limit`, limit);
+        validateWithNumber(`${def.table.name}.${key}.offset`, offset);
+        if ((limit !== undefined || offset !== undefined) && orderBy === undefined) {
+            throw new Error(`with: ${def.table.name}.${key} 使用 limit/offset 时必须提供 orderBy`);
+        }
+        const values = [...new Set(rows.map(r => r[from.outKey]).filter(v => v !== null && v !== undefined))];
+        let children = [];
+        if (values.length > 0) {
+            let text;
+            let params;
+            if (limit !== undefined || offset !== undefined) {
+                const alias = '__zd_rel';
+                const order = compileOrderBy(def.table, orderBy);
+                if (!order)
+                    throw new Error(`with: ${def.table.name}.${key} 的 orderBy 不能为空`);
+                const wherePart = where === undefined
+                    ? { text: '', params: [] }
+                    : compileWhere(def.table, where, 1, [], alias);
+                params = [values, ...wherePart.params];
+                const predicate = wherePart.text ? ` and (${wherePart.text})` : '';
+                const lo = offset ?? 0;
+                const hi = lo + limit;
+                text = `select * from (`
+                    + `select ${quoteIdent(alias)}.*, row_number() over (partition by ${quoteIdent(alias)}.${quoteIdent(to.dbKey)} order by ${order}) as "__zd_rn"`
+                    + ` from ${quoteIdent(def.table.name)} as ${quoteIdent(alias)}`
+                    + ` where ${quoteIdent(alias)}.${quoteIdent(to.dbKey)} = any($1)${predicate}`
+                    + `) as "__zd_rel_rows" where "__zd_rel_rows"."__zd_rn" > ${lo} and "__zd_rel_rows"."__zd_rn" <= ${hi}`;
+            }
+            else {
+                const wherePart = where === undefined
+                    ? { text: '', params: [] }
+                    : compileWhere(def.table, where, 1, []);
+                params = [values, ...wherePart.params];
+                const predicate = wherePart.text ? ` and (${wherePart.text})` : '';
+                const order = orderBy === undefined ? '' : compileOrderBy(def.table, orderBy);
+                text = `select * from ${quoteIdent(def.table.name)} where ${quoteIdent(to.dbKey)} = any($1)${predicate}`;
+                if (order)
+                    text += ` order by ${order}`;
+            }
+            const childRows = await exec(ctx, text, params, { operation: 'with', table: def.table.name });
+            children = childRows.map((row, i) => mapRow(row, def.table, undefined, ctx.shouldValidate, i));
+        }
+        const buckets = new Map();
+        for (const child of children) {
+            const k = child[to.outKey];
+            const bucket = buckets.get(k);
+            if (bucket)
+                bucket.push(child);
+            else
+                buckets.set(k, [child]);
+        }
+        for (const row of rows) {
+            const k = row[from.outKey];
+            const bucket = k === null || k === undefined ? undefined : buckets.get(k);
+            row[key] = def._kind === 'many' ? (bucket ?? []) : (bucket?.[0] ?? null);
+        }
+        if (nested.length > 0 && children.length > 0)
+            await attachRelations(ctx, children, nested, depth + 1);
+        if (aggregate)
+            await attachAggregate(ctx, rows, key, def, aggregate, where);
+    }
+}
+async function findManyImpl(ctx, table, opts = {}) {
+    const resolved = opts.with ? resolveWith(ctx, table, opts.with, 1) : [];
+    const selectEntries = opts.select ? Object.entries(opts.select).filter(([, v]) => v) : null;
+    if (selectEntries && selectEntries.length === 0)
+        throw new Error('select 不能为空');
+    const selectKeys = selectEntries ? selectEntries.map(([k]) => k) : null;
+    const hidden = new Set();
+    if (selectKeys) {
+        for (const { def } of resolved) {
+            const from = resolveRelationColumn(def.from);
+            if (!selectKeys.includes(from.outKey)) {
+                selectKeys.push(from.outKey);
+                hidden.add(from.outKey);
+            }
+        }
+    }
+    const sel = selectKeys ? makeSelect(ctx, table, selectKeys) : null;
+    const where = opts.where === undefined ? { text: '', params: [] } : compileWhere(table, opts.where, 0, ctx.relations);
+    const order = opts.orderBy === undefined ? '' : compileOrderBy(table, opts.orderBy);
+    const params = [...where.params];
+    const conditions = [];
+    if (where.text)
+        conditions.push(where.text);
+    if (opts.cursor !== undefined) {
+        const c = compileCursor(table, opts.orderBy, opts.cursor, params.length + 1);
+        conditions.push(c.text);
+        params.push(...c.params);
+    }
+    let text = `select ${sel ? sel.toSQL() : '*'} from ${quoteIdent(table.name)}`;
+    if (conditions.length > 0)
+        text += ` where ${conditions.join(' and ')}`;
+    if (order)
+        text += ` order by ${order}`;
+    if (opts.limit !== undefined) {
+        if (!Number.isInteger(opts.limit) || opts.limit < 0)
+            throw new Error('limit 必须是非负整数');
+        params.push(opts.limit);
+        text += ` limit $${params.length}`;
+    }
+    if (opts.offset !== undefined) {
+        if (!Number.isInteger(opts.offset) || opts.offset < 0)
+            throw new Error('offset 必须是非负整数');
+        params.push(opts.offset);
+        text += ` offset $${params.length}`;
+    }
+    const rows = await exec(ctx, text, params, { operation: 'find', table: table.name });
+    const mapped = sel
+        ? rows.map((row, i) => (ctx.shouldValidate ? sel.__mapValid(row, i) : sel.__mapFast(row)))
+        : rows.map((row, i) => mapRow(row, table, undefined, ctx.shouldValidate, i));
+    if (resolved.length > 0)
+        await attachRelations(ctx, mapped, resolved);
+    if (hidden.size > 0) {
+        for (const row of mapped)
+            for (const k of hidden)
+                delete row[k];
+    }
+    return mapped;
+}
+async function findOneImpl(ctx, table, opts = {}) {
+    const rows = await findManyImpl(ctx, table, { ...opts, limit: 1 });
+    return rows[0] ?? null;
+}
+export function createDb(conn, validate = 'always', relations = [], opts = {}) {
+    const seen = new Set();
+    for (const r of relations) {
+        if (seen.has(r.table))
+            throw new Error(`relations: 表 ${r.table.name} 定义了多组 relations()`);
+        seen.add(r.table);
+    }
+    const ctx = {
+        raw: conn,
+        validate,
+        shouldValidate: validate === 'always',
+        relations,
+        hooks: opts.hooks,
+        slowQueryMs: opts.slowQueryMs,
+        replica: opts.replica,
+    };
+    const db = {
+        raw: conn,
+        sql: ((strings, ...params) => {
+            const args = params.map(p => isSelectFragment(p) ? p.__fragment : p);
+            assertParams(args);
+            const c = ctx.raw;
+            const text = strings.reduce((out, part, i) => out + part + (i < args.length ? `$${i + 1}` : ''), '');
+            return new Query(ctx, () => c(strings, ...args), text, args);
+        }),
+        select: ((table, columns) => makeSelect(ctx, table, columns ? Object.keys(columns) : Object.keys(table.columns))),
+        insert: (table, values) => insertImpl(ctx, table, values),
+        insertMany: (table, values, opts) => insertManyImpl(ctx, table, values, opts?.chunkSize),
+        create: ((table, input) => createImpl(ctx, table, input)),
+        seed: ((table, rows, opts) => seedImpl(ctx, table, rows, opts)),
+        update: (table, values, where) => updateImpl(ctx, table, values, where),
+        delete: (table, where) => deleteImpl(ctx, table, where),
+        upsert: (table, values, opts) => upsertImpl(ctx, table, values, opts),
+        count: (table, where) => countImpl(readCtx(ctx), table, where),
+        aggregate: (async (table, opts) => {
+            const rc = readCtx(ctx);
+            return (await aggregateImpl(rc.raw, table, opts, false, (sql, params, meta) => exec(rc, sql, params, meta)))[0];
+        }),
+        groupBy: ((table, opts) => {
+            const rc = readCtx(ctx);
+            return aggregateImpl(rc.raw, table, opts, true, (sql, params, meta) => exec(rc, sql, params, meta));
+        }),
+        findMany: ((table, opts) => findManyImpl(readCtx(ctx), table, opts)),
+        findOne: ((table, opts) => findOneImpl(readCtx(ctx), table, opts)),
+        begin(fn, opts = {}) {
+            if (opts.isolation !== undefined && !ISOLATION_LEVELS.includes(opts.isolation)) {
+                throw new Error(`begin: 不支持的隔离级别 ${String(opts.isolation)}（可选：${ISOLATION_LEVELS.join(' / ')}）`);
+            }
+            const options = opts.isolation ? `isolation level ${opts.isolation}` : '';
+            const tx = conn.begin(options, (txSql) => fn(createDb(txSql, validate, ctx.relations, { hooks: ctx.hooks, slowQueryMs: ctx.slowQueryMs })));
+            return tx;
+        },
+        close: async () => {
+            const targets = new Set([conn]);
+            if (ctx.replica)
+                targets.add(ctx.replica);
+            await Promise.all([...targets].map(c => c.end({ timeout: 5 })));
+        },
+    };
+    return db;
+}
+export function defineDb(opts) {
+    // notice 默认静音：`drop table if exists` 之类的 NOTICE 不该刷屏
+    const conn = opts.connection ?? postgres(opts.url ?? process.env.DATABASE_URL ?? '', { onnotice: () => { } });
+    const replica = opts.replica ?? (opts.replicaUrl ? postgres(opts.replicaUrl, { onnotice: () => { } }) : undefined);
+    return createDb(conn, opts.validate ?? 'always', (opts.relations ?? []), {
+        hooks: opts.hooks,
+        slowQueryMs: opts.slowQueryMs,
+        replica,
+    });
+}
+//# sourceMappingURL=db.js.map