@ailnaf/zoddb 0.1.0 → 0.3.0

package/dist/db.js

@@ -49,10 +49,22 @@ async function trackQuery(ctx, meta, fn, countRows) {
         throw error;
     }
 }
-async function exec(ctx, text, params = [], meta = { operation: 'query' }) {
-    return trackQuery(ctx, { ...meta, sql: text, params }, () => ctx.raw.unsafe(text, params));
+async function exec(ctx, text, params = [], meta = { operation: 'query' }, countRows) {
+    return trackQuery(ctx, { ...meta, sql: text, params }, () => ctx.raw.unsafe(text, params), countRows);
 }
 const readCtx = (ctx) => ctx.replica ? { ...ctx, raw: ctx.replica, onReplica: true } : ctx;
+async function rawQueryImpl(ctx, text, params = []) {
+    assertParams(params);
+    try {
+        return await exec(ctx, text, params, { operation: 'raw' }, result => {
+            const count = result.count;
+            return typeof count === 'number' ? count : result.length;
+        });
+    }
+    catch (e) {
+        throw mapError(e);
+    }
+}
 const quoteIdent = (s) => `"${s.replace(/"/g, '""')}"`;
 /** 顶层用 begin；已在事务里时用 savepoint（postgres.js 的 TransactionSql 没有 begin） */
 function beginOrSavepoint(conn, cb) {
@@ -412,6 +424,171 @@ async function applyLinkWrite(ctx, parent, table, key, def, value) {
         await insertLinkRows(ctx, def, sourceValue, targets, `${operation}.connect`);
     }
 }
+async function applyOneUpdate(ctx, parent, table, key, def, value) {
+    const operation = `update ${table.name}.${key}`;
+    if (!isPlainObject(value))
+        throw new Error(`${operation} 需要 { connect } 或 { disconnect }`);
+    const hasConnect = value.connect !== undefined;
+    const hasDisconnect = value.disconnect !== undefined;
+    for (const k of Object.keys(value)) {
+        if (k !== 'connect' && k !== 'disconnect')
+            throw new Error(`${operation} 不支持选项 ${k}`);
+    }
+    if (hasConnect === hasDisconnect)
+        throw new Error(`${operation} 需要 connect/disconnect 二选一`);
+    if (hasDisconnect && value.disconnect !== true)
+        throw new Error(`${operation}.disconnect 必须是 true`);
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const parentPks = table.__plan.filter(p => p.pk);
+    if (parentPks.length !== 1)
+        throw new Error(`${operation}: 父表 ${table.name} 必须使用单列主键`);
+    const parentPk = parentPks[0];
+    const parentValue = parent[parentPk.outKey];
+    if (parentValue === undefined || parentValue === null)
+        throw new Error(`${operation}: ${table.name}.${parentPk.outKey} 不能为空`);
+    const fromPlan = table.__plan.find(p => p.outKey === from.outKey);
+    if (!fromPlan)
+        throw new Error(`${operation}: 找不到 ${table.name}.${from.outKey}`);
+    const setParentFk = async (targetValue) => {
+        const rows = await updateColumnsImpl(ctx, table, { [from.outKey]: targetValue }, {
+            [parentPk.outKey]: parentValue,
+        });
+        if (rows.length !== 1)
+            throw new Error(`${operation}: 父行 ${String(parentValue)} 不存在`);
+    };
+    if (hasDisconnect) {
+        if (!fromPlan.nullable)
+            throw new Error(`${operation}: ${table.name}.${from.outKey} 不是 nullable，不能 disconnect`);
+        await setParentFk(null);
+        return;
+    }
+    if (!isPlainObject(value.connect))
+        throw new Error(`${operation}.connect 必须是对象`);
+    const targetPks = def.table.__plan.filter(p => p.pk);
+    if (targetPks.length !== 1)
+        throw new Error(`${operation}: 目标表 ${def.table.name} 必须使用单列主键`);
+    const targetPk = targetPks[0];
+    const targetId = value.connect[targetPk.outKey];
+    if (targetId === undefined || targetId === null)
+        throw new Error(`${operation}.connect 需要 ${def.table.name}.${targetPk.outKey}`);
+    const target = await findOneImpl(ctx, def.table, { where: { [targetPk.outKey]: targetId } });
+    if (!target)
+        throw new Error(`${operation}: 找不到 ${def.table.name}.${String(targetId)}`);
+    const targetValue = target[to.outKey];
+    if (targetValue === undefined || targetValue === null)
+        throw new Error(`${operation}: ${def.table.name}.${to.outKey} 不能为空`);
+    await setParentFk(targetValue);
+}
+async function applyManyUpdate(ctx, parent, table, key, def, value) {
+    const operation = `update ${table.name}.${key}`;
+    if (!isPlainObject(value))
+        throw new Error(`${operation} 需要 { create, update, delete } 之一`);
+    const allowed = new Set(['create', 'update', 'delete']);
+    for (const k of Object.keys(value)) {
+        if (!allowed.has(k))
+            throw new Error(`${operation} 不支持选项 ${k}`);
+    }
+    const parseList = (name) => {
+        const raw = value[name];
+        if (raw === undefined)
+            return undefined;
+        if (!Array.isArray(raw))
+            throw new Error(`${operation}.${name} 必须是数组`);
+        return raw;
+    };
+    const creates = parseList('create');
+    const updates = parseList('update');
+    const deletes = parseList('delete');
+    if (creates === undefined && updates === undefined && deletes === undefined) {
+        throw new Error(`${operation} 需要 create/update/delete 之一`);
+    }
+    const from = resolveRelationColumn(def.from);
+    const to = resolveRelationColumn(def.to);
+    const parentValue = parent[from.outKey];
+    if (parentValue === undefined || parentValue === null)
+        throw new Error(`${operation}: ${table.name}.${from.outKey} 不能为空`);
+    const childPks = def.table.__plan.filter(p => p.pk);
+    if (childPks.length !== 1)
+        throw new Error(`${operation}: 目标表 ${def.table.name} 必须使用单列主键`);
+    const childPk = childPks[0];
+    const updateItems = [];
+    const updateIds = new Set();
+    if (updates) {
+        for (const [index, patch] of updates.entries()) {
+            if (!isPlainObject(patch))
+                throw new Error(`${operation}.update[${index}] 必须是对象`);
+            const id = patch[childPk.outKey];
+            if (id === undefined || id === null)
+                throw new Error(`${operation}.update[${index}] 需要 ${def.table.name}.${childPk.outKey}`);
+            if (updateIds.has(id))
+                throw new Error(`${operation}.update[${index}] 重复子行 ${String(id)}`);
+            updateIds.add(id);
+            const values = { ...patch };
+            delete values[childPk.outKey];
+            if (Object.keys(values).length === 0)
+                throw new Error(`${operation}.update[${index}] patch 至少需要一个字段`);
+            if (to.outKey in values)
+                throw new Error(`${operation}.update[${index}] 不能修改外键 ${def.table.name}.${to.outKey}`);
+            updateItems.push({ id, values });
+        }
+    }
+    const deleteItems = [];
+    const deleteIds = new Set();
+    if (deletes) {
+        for (const [index, spec] of deletes.entries()) {
+            if (!isPlainObject(spec))
+                throw new Error(`${operation}.delete[${index}] 必须是对象`);
+            const keys = Object.keys(spec);
+            if (keys.length !== 1 || keys[0] !== childPk.outKey) {
+                throw new Error(`${operation}.delete[${index}] 只允许 { ${childPk.outKey} }`);
+            }
+            const id = spec[childPk.outKey];
+            if (id === undefined || id === null)
+                throw new Error(`${operation}.delete[${index}] 需要 ${def.table.name}.${childPk.outKey}`);
+            if (deleteIds.has(id))
+                throw new Error(`${operation}.delete[${index}] 重复子行 ${String(id)}`);
+            deleteIds.add(id);
+            deleteItems.push(id);
+        }
+    }
+    for (const id of updateIds) {
+        if (deleteIds.has(id))
+            throw new Error(`${operation}: 子行 ${String(id)} 不能同时 update 和 delete`);
+    }
+    if (creates) {
+        for (const [index, row] of creates.entries()) {
+            if (!isPlainObject(row))
+                throw new Error(`${operation}.create[${index}] 必须是对象`);
+            const id = row[childPk.outKey];
+            if (id !== undefined && id !== null && (updateIds.has(id) || deleteIds.has(id))) {
+                throw new Error(`${operation}.create[${index}]: 子行 ${String(id)} 与 update/delete 冲突`);
+            }
+        }
+    }
+    if (creates && creates.length > 0) {
+        const values = creates.map(row => ({ ...row, [to.outKey]: parentValue }));
+        await insertManyImpl(ctx, def.table, values);
+    }
+    for (const { id, values } of updateItems) {
+        const rows = await updateColumnsImpl(ctx, def.table, values, {
+            [childPk.outKey]: id,
+            [to.outKey]: parentValue,
+        });
+        if (rows.length !== 1) {
+            throw new Error(`${operation}: 子行 ${String(id)} 不存在或不属于父行 ${String(parentValue)}`);
+        }
+    }
+    for (const id of deleteItems) {
+        const deleted = await deleteImpl(ctx, def.table, {
+            [childPk.outKey]: id,
+            [to.outKey]: parentValue,
+        });
+        if (deleted !== 1) {
+            throw new Error(`${operation}: 子行 ${String(id)} 不存在或不属于父行 ${String(parentValue)}`);
+        }
+    }
+}
 async function createImpl(ctx, table, input) {
     const rels = ctx.relations.find(r => r.table === table);
     const columns = {};
@@ -550,6 +727,8 @@ async function updateImpl(ctx, table, values, where) {
     const rels = ctx.relations.find(r => r.table === table);
     const columns = {};
     const links = [];
+    const manyUpdates = [];
+    const oneUpdates = [];
     const unknown = [];
     for (const [k, v] of Object.entries(values)) {
         if (v === undefined)
@@ -563,8 +742,16 @@ async function updateImpl(ctx, table, values, where) {
             links.push({ key: k, def, value: v });
             continue;
         }
+        if (def?._kind === 'many') {
+            manyUpdates.push({ key: k, def, value: v });
+            continue;
+        }
+        if (def?._kind === 'one') {
+            oneUpdates.push({ key: k, def, value: v });
+            continue;
+        }
         if (def)
-            throw new Error(`update: ${table.name}.${k} 不支持关系写入（只有 M2M through 支持）`);
+            throw new Error(`update: ${table.name}.${k} 不支持关系写入（只有 M2M through / many / one 支持）`);
         unknown.push(k);
     }
     // 保留既有 update 的 ZodError 语义：未知列先交给严格 schema 报错。
@@ -573,7 +760,20 @@ async function updateImpl(ctx, table, values, where) {
             table.updateSchema.parse(values);
         throw new Error(`update: 未知字段 ${table.name}.${unknown[0]}`);
     }
-    if (links.length === 0)
+    const relationWrites = links.length > 0 || manyUpdates.length > 0 || oneUpdates.length > 0;
+    if (relationWrites) {
+        const pkKeys = table.__plan.filter(p => p.pk).map(p => p.outKey);
+        const changedPk = pkKeys.find(k => columns[k] !== undefined);
+        if (changedPk)
+            throw new Error(`update: 关系写入时不能修改父主键 ${table.name}.${changedPk}`);
+        for (const { key, def } of oneUpdates) {
+            const from = resolveRelationColumn(def.from);
+            if (columns[from.outKey] !== undefined) {
+                throw new Error(`update: ${table.name}.${key} 与父外键 ${table.name}.${from.outKey} 冲突`);
+            }
+        }
+    }
+    if (!relationWrites)
         return updateColumnsImpl(ctx, table, columns, where);
     return beginOrSavepoint(ctx.raw, async (txSql) => {
         const tx = { ...ctx, raw: txSql };
@@ -585,9 +785,15 @@ async function updateImpl(ctx, table, values, where) {
             rows = await findManyImpl(tx, table, { where: where, limit: 2 });
         }
         if (rows.length !== 1) {
-            throw new Error(`update: M2M 关系写入要求 where 命中恰好 1 行（命中 ${rows.length} 行）`);
+            throw new Error(`update: 关系写入要求 where 命中恰好 1 行（命中 ${rows.length} 行）`);
         }
         const parent = rows[0];
+        for (const { key, def, value } of manyUpdates) {
+            await applyManyUpdate(tx, parent, table, key, def, value);
+        }
+        for (const { key, def, value } of oneUpdates) {
+            await applyOneUpdate(tx, parent, table, key, def, value);
+        }
         for (const { key, def, value } of links) {
             await applyLinkWrite(tx, parent, table, key, def, value);
         }
@@ -645,7 +851,52 @@ async function countImpl(ctx, table, where) {
     const rows = await exec(ctx, text, w?.params ?? [], { operation: 'count', table: table.name });
     return rows[0]?.n ?? 0;
 }
-function resolveWith(ctx, table, withMap) {
+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 [];
@@ -662,13 +913,13 @@ function resolveWith(ctx, table, withMap) {
             throw new Error(`with: ${table.name}.${key} 只支持 true/false 或关系选项对象`);
         }
         const opts = enabled;
-        const allowed = new Set(['where', 'orderBy', 'limit', 'offset', 'with']);
+        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 之一`);
+            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`);
         }
@@ -678,6 +929,10 @@ function resolveWith(ctx, table, withMap) {
         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,
@@ -686,10 +941,11 @@ function resolveWith(ctx, table, withMap) {
             limit: opts.limit,
             offset: opts.offset,
             with: opts.with,
+            aggregate,
         };
     });
 }
-async function attachThroughRelation(ctx, rows, key, def, through, nested) {
+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);
@@ -727,7 +983,7 @@ async function attachThroughRelation(ctx, rows, key, def, through, nested) {
         row[key] = bucket;
     }
     if (nested.length > 0 && children.length > 0)
-        await attachRelations(ctx, children, nested);
+        await attachRelations(ctx, children, nested, depth);
 }
 function validateWithNumber(name, value) {
     if (value === undefined)
@@ -735,11 +991,76 @@ function validateWithNumber(name, value) {
     if (!Number.isInteger(value) || value < 0)
         throw new Error(`with: ${name} 必须是非负整数`);
 }
-async function attachRelations(ctx, rows, resolved) {
-    for (const { key, def, where, orderBy, limit, offset, with: nestedInput } of resolved) {
-        const nested = nestedInput !== undefined ? resolveWith(ctx, def.table, nestedInput) : [];
+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);
+            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);
@@ -807,11 +1128,13 @@ async function attachRelations(ctx, rows, resolved) {
             row[key] = def._kind === 'many' ? (bucket ?? []) : (bucket?.[0] ?? null);
         }
         if (nested.length > 0 && children.length > 0)
-            await attachRelations(ctx, children, nested);
+            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) : [];
+    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 不能为空');
@@ -890,6 +1213,7 @@ export function createDb(conn, validate = 'always', relations = [], opts = {}) {
     };
     const db = {
         raw: conn,
+        rawQuery: (text, params) => rawQueryImpl(ctx, text, params),
         sql: ((strings, ...params) => {
             const args = params.map(p => isSelectFragment(p) ? p.__fragment : p);
             assertParams(args);