neoorm 0.8.0 → 0.8.2

package/dist/runtime/query/relation-writes.js

@@ -1,11 +1,13 @@
-import { postgresDialect, quoteIdentifier, tableRef, } from "../../dialect/postgres.js";
+import { parseFkTarget, relationFkPairs } from "../../dialect/fk.js";
+import { joinPlaceholders } from "../../dialect/placeholders.js";
+import { postgresDialect } from "../../dialect/postgres.js";
 import { compileError } from "../compile-error.js";
 import { QueryErrorCode } from "../error-codes.js";
 import { buildInsertManyQuery, buildInsertManyValueRows, dataToSqlValues, } from "./compile.js";
 import { runQuery } from "./execute.js";
-import { findOrCreatePk } from "./find-or-create.js";
+import { findOrCreatePk, findOrCreateRecord } from "./find-or-create.js";
 import { findM2M, findRelation, tableOwnsFkColumn } from "./manifest-lookup.js";
-import { fillMissingPrimaryKeys, primaryKeySqlName, requireScalarPrimaryKey, rowScalarPkValue, targetRelationPkSql, } from "./primary-key.js";
+import { fillMissingPrimaryKeys, primaryKeySqlName, primaryKeyTsNames, resolvePkWhere, targetRelationPkSql, } from "./primary-key.js";
 import { columnBySqlName, columnByTsName, getTableIndex, requireTable, requireTsColumn, } from "./table-index.js";
 const RELATION_WRITE_KEYS = [
     "delete",
@@ -56,31 +58,148 @@ function connectPkError(table, pkTsName, detail) {
         code: QueryErrorCode.missing_primary_key,
         tableAccessor: table.accessor,
         tableSqlName: table.sqlName,
-        columnTsName: pkTsName,
+        ...(pkTsName !== undefined ? { columnTsName: pkTsName } : {}),
     });
 }
-function readConnectPk(item, pkTsName, table) {
-    if (!item || typeof item !== "object" || Array.isArray(item)) {
-        connectPkError(table, pkTsName, `Relation connect requires { ${pkTsName}: ... } for table "${table.accessor}"`);
+function normalizeConnectPks(runtime, targetAccessor, value) {
+    const table = requireTable(runtime.manifest, targetAccessor, "select");
+    const tableIndex = getTableIndex(runtime.tableIndex, targetAccessor);
+    if (value == null || value === false)
+        return [];
+    const items = Array.isArray(value) ? value : [value];
+    return items.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            const pkNames = primaryKeyTsNames(table, tableIndex);
+            connectPkError(table, pkNames[0], `Relation connect requires { ${pkNames.join(", ")} } for table "${table.accessor}"`);
+        }
+        return resolvePkWhere(table, item, tableIndex);
+    });
+}
+function pkField(table, pk, tsName) {
+    const value = pk[tsName];
+    if (value == null) {
+        connectPkError(table, tsName, `Relation connect requires primary key "${tsName}" for table "${table.accessor}"`);
     }
-    const id = item[pkTsName];
-    if (id == null) {
-        connectPkError(table, pkTsName, `Relation connect requires primary key "${pkTsName}" for table "${table.accessor}"`);
+    return value;
+}
+function assignOutgoingFkScalars(scalarData, rel, targetTable, targetIndex, record, nulls = false) {
+    for (const pair of relationFkPairs(rel)) {
+        if (nulls) {
+            scalarData[pair.fkColumn] = null;
+            continue;
+        }
+        const targetTs = columnBySqlName(targetIndex, targetTable, pair.targetColumn)
+            ?.tsName ??
+            columnByTsName(targetIndex, targetTable, pair.targetColumn)
+                ?.tsName ??
+            pair.targetColumn;
+        scalarData[pair.fkColumn] = pkField(targetTable, record, targetTs);
     }
-    return String(id);
 }
-function normalizeIdList(value, pkTsName, table) {
-    if (value == null || value === false)
-        return [];
-    if (Array.isArray(value)) {
-        return value.map((item) => readConnectPk(item, pkTsName, table));
+function childFkCreatePatch(rel, parentTable, parentRow, parentId) {
+    const assignment = inverseFkAssignments(rel, parentTable, parentRow, parentId);
+    const pairs = relationFkPairs(rel);
+    const patch = {};
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        if (!pair)
+            continue;
+        patch[pair.fkColumn] = assignment.values[i] ?? parentId;
     }
-    return [readConnectPk(value, pkTsName, table)];
+    return patch;
 }
-function normalizeConnectIds(runtime, targetAccessor, value) {
-    const table = requireTable(runtime.manifest, targetAccessor, "select");
-    const { tsName } = requireScalarPrimaryKey(table, "connect", getTableIndex(runtime.tableIndex, targetAccessor));
-    return normalizeIdList(value, tsName, table);
+function inverseFkAssignments(rel, parentTable, parentRow, parentId) {
+    const pairs = relationFkPairs(rel);
+    const refs = rel.referencedSqlColumns && rel.referencedSqlColumns.length > 0
+        ? rel.referencedSqlColumns
+        : pairs.map((pair) => pair.targetColumn);
+    if (pairs.length <= 1) {
+        return {
+            sqlNames: [rel.fkSqlColumn],
+            values: [parentId],
+        };
+    }
+    const values = pairs.map((pair, i) => {
+        const ref = refs[i] ?? pair.targetColumn;
+        const col = parentTable.columns.find((item) => item.sqlName === ref || item.tsName === ref);
+        const value = parentRow?.[col?.tsName ?? ref];
+        return value ?? parentId;
+    });
+    return {
+        sqlNames: pairs.map((pair) => pair.fkSqlColumn),
+        values,
+    };
+}
+function fkTargetTsName(table, tableIndex, relation, throughFk) {
+    if (throughFk?.fkTarget) {
+        const { columnSql } = parseFkTarget(throughFk.fkTarget);
+        const col = columnBySqlName(tableIndex, table, columnSql) ??
+            columnByTsName(tableIndex, table, columnSql);
+        if (col)
+            return col.tsName;
+    }
+    const sql = targetRelationPkSql(table, relation);
+    const col = columnBySqlName(tableIndex, table, sql) ??
+        columnByTsName(tableIndex, table, sql);
+    if (col)
+        return col.tsName;
+    const names = primaryKeyTsNames(table, tableIndex);
+    const first = names[0];
+    if (!first) {
+        connectPkError(table, undefined, `No primary key defined for table "${table.accessor}"`);
+    }
+    return first;
+}
+function m2mOtherThroughColumn(runtime, m2m, parentAccessor) {
+    const throughTable = runtime.manifest.tables[m2m.throughAccessor];
+    if (!throughTable)
+        return undefined;
+    const throughIndex = getTableIndex(runtime.tableIndex, throughTable.accessor);
+    const isLeft = m2m.leftAccessor === parentAccessor;
+    const otherFkCol = isLeft ? m2m.rightFkColumn : m2m.leftFkColumn;
+    return columnBySqlName(throughIndex, throughTable, otherFkCol);
+}
+function m2mConnectFkValues(runtime, m2m, parentAccessor, targetAccessor, value) {
+    const pks = normalizeConnectPks(runtime, targetAccessor, value);
+    const targetTable = requireTable(runtime.manifest, targetAccessor, "select");
+    const targetIndex = getTableIndex(runtime.tableIndex, targetAccessor);
+    const throughFk = m2mOtherThroughColumn(runtime, m2m, parentAccessor);
+    const fkTs = fkTargetTsName(targetTable, targetIndex, undefined, throughFk);
+    return { pks, ids: extractFkValues(targetTable, pks, fkTs) };
+}
+function extractFkValues(table, pks, fkTsName) {
+    return pks.map((pk) => pkField(table, pk, fkTsName));
+}
+function sqlPkPredicate(dialect, table, tableIndex, pks, startParam) {
+    const tsNames = primaryKeyTsNames(table, tableIndex);
+    if (tsNames.length === 0 || pks.length === 0) {
+        connectPkError(table, undefined, `No primary key defined for table "${table.accessor}"`);
+    }
+    const quoted = tsNames.map((tsName) => {
+        const col = columnByTsName(tableIndex, table, tsName);
+        return dialect.quoteIdentifier(col?.sqlName ?? tsName);
+    });
+    if (tsNames.length === 1) {
+        const tsName = tsNames[0];
+        if (!tsName || !quoted[0]) {
+            connectPkError(table, tsName, `No primary key defined for table "${table.accessor}"`);
+        }
+        const placeholders = joinPlaceholders(dialect, pks.length, startParam);
+        return {
+            sql: `${quoted[0]} IN (${placeholders})`,
+            params: pks.map((pk) => pkField(table, pk, tsName)),
+        };
+    }
+    const params = [];
+    let index = startParam;
+    const groups = pks.map((pk) => {
+        const parts = tsNames.map((tsName, i) => {
+            params.push(pkField(table, pk, tsName));
+            return `${quoted[i]} = ${dialect.placeholder(index++)}`;
+        });
+        return `(${parts.join(" AND ")})`;
+    });
+    return { sql: `(${groups.join(" OR ")})`, params };
 }
 function normalizeCreateList(value) {
     if (!value)
@@ -109,10 +228,10 @@ export function splitScalarsAndRelationWrites(manifest, tableAccessor, table, da
     }
     return { scalarData, relationWrites };
 }
-export async function resolveConnectOrCreate(executor, runtime, targetAccessor, items) {
+export async function resolveConnectOrCreate(executor, runtime, targetAccessor, items, fkTsName) {
     const ids = [];
     for (const item of items) {
-        const id = await findOrCreatePk(executor, runtime, targetAccessor, item);
+        const id = await findOrCreatePk(executor, runtime, targetAccessor, item, fkTsName);
         ids.push(id);
     }
     return ids;
@@ -167,11 +286,11 @@ async function insertM2MLinks(executor, runtime, m2m, parentAccessor, parentId,
         const valueByKey = new Map(keys.map((key, i) => [key, values[i]]));
         return dataKeys.map((key) => valueByKey.get(key));
     });
-    const { valueRows, values } = buildInsertManyValueRows(throughTable, dataKeys, rowValues, runtime.tableIndex);
+    const { valueRows, values } = buildInsertManyValueRows(throughTable, dataKeys, rowValues, runtime.tableIndex, dialect);
     const sql = buildInsertManyQuery(throughTable, dataKeys, valueRows, runtime.tableIndex, true, dialect);
     await runQuery(executor, runtime, { operation: "insert", tableAccessor: throughTable.accessor }, sql, values);
 }
-async function insertJunctionRows(executor, runtime, throughAccessor, leftFkCol, rightFkCol, leftId, rightIds) {
+async function _insertJunctionRows(executor, runtime, throughAccessor, leftFkCol, _rightFkCol, leftId, rightIds) {
     const { manifest } = runtime;
     const m2m = manifest.manyToMany.find((m) => m.throughAccessor === throughAccessor);
     if (!m2m) {
@@ -181,6 +300,7 @@ async function insertJunctionRows(executor, runtime, throughAccessor, leftFkCol,
     await insertM2MLinks(executor, runtime, m2m, parentAccessor, leftId, rightIds);
 }
 async function deleteJunctionRows(executor, runtime, m2m, parentAccessor, parentId, rightIds) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const throughTable = manifest.tables[m2m.throughAccessor];
     if (!throughTable)
@@ -194,10 +314,10 @@ async function deleteJunctionRows(executor, runtime, m2m, parentAccessor, parent
     if (!parentCol || !otherCol)
         return;
     const params = [parentId];
-    let sql = `DELETE FROM ${tableRef(throughTable)} WHERE ${quoteIdentifier(parentCol.sqlName)} = $1`;
+    let sql = `DELETE FROM ${dialect.tableRef(throughTable)} WHERE ${dialect.quoteIdentifier(parentCol.sqlName)} = ${dialect.placeholder(1)}`;
     if (rightIds && rightIds.length > 0) {
-        const placeholders = rightIds.map((_, i) => `$${i + 2}`).join(", ");
-        sql += ` AND ${quoteIdentifier(otherCol.sqlName)} IN (${placeholders})`;
+        const placeholders = joinPlaceholders(dialect, rightIds.length, 2);
+        sql += ` AND ${dialect.quoteIdentifier(otherCol.sqlName)} IN (${placeholders})`;
         params.push(...rightIds);
     }
     await runQuery(executor, runtime, { operation: "delete", tableAccessor: throughTable.accessor }, sql, params);
@@ -210,56 +330,63 @@ function childFkColumnMeta(targetTable, relation, tableIndex) {
     }
     return col;
 }
-async function connectInverseMany(executor, runtime, relation, parentId, childIds) {
+async function connectInverseMany(executor, runtime, relation, parentId, childPks, parentTable, parentRow) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const targetTable = manifest.tables[relation.targetAccessor];
-    if (!targetTable || childIds.length === 0)
+    if (!targetTable || childPks.length === 0)
         return;
-    const fkCol = childFkColumnMeta(targetTable, relation, getTableIndex(runtime.tableIndex, targetTable.accessor));
-    const placeholders = childIds.map((_, i) => `$${i + 2}`).join(", ");
-    const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
-    await runQuery(executor, runtime, { operation: "update", tableAccessor: relation.targetAccessor }, `UPDATE ${tableRef(targetTable)} SET ${quoteIdentifier(fkCol.sqlName)} = $1 WHERE ${targetPkCol} IN (${placeholders})`, [parentId, ...childIds]);
+    const targetIndex = getTableIndex(runtime.tableIndex, targetTable.accessor);
+    const assignment = inverseFkAssignments(relation, parentTable ?? targetTable, parentRow, parentId);
+    const predicate = sqlPkPredicate(dialect, targetTable, targetIndex, childPks, assignment.values.length + 1);
+    const setSql = assignment.sqlNames
+        .map((sqlName, i) => `${dialect.quoteIdentifier(sqlName)} = ${dialect.placeholder(i + 1)}`)
+        .join(", ");
+    await runQuery(executor, runtime, { operation: "update", tableAccessor: relation.targetAccessor }, `UPDATE ${dialect.tableRef(targetTable)} SET ${setSql} WHERE ${predicate.sql}`, [...assignment.values, ...predicate.params]);
 }
-async function disconnectInverseMany(executor, runtime, relation, parentId, childIds) {
+async function disconnectInverseMany(executor, runtime, relation, parentId, childPks) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const targetTable = manifest.tables[relation.targetAccessor];
     if (!targetTable)
         return;
-    const fkCol = childFkColumnMeta(targetTable, relation, getTableIndex(runtime.tableIndex, targetTable.accessor));
+    const targetIndex = getTableIndex(runtime.tableIndex, targetTable.accessor);
+    const fkCol = childFkColumnMeta(targetTable, relation, targetIndex);
     if (!fkCol.nullable) {
         compileError(`Cannot disconnect relation ${relation.name}: FK column is not nullable`);
     }
     const params = [parentId];
-    let sql = `UPDATE ${tableRef(targetTable)} SET ${quoteIdentifier(fkCol.sqlName)} = NULL WHERE ${quoteIdentifier(fkCol.sqlName)} = $1`;
-    if (childIds && childIds.length > 0) {
-        const placeholders = childIds.map((_, i) => `$${i + 2}`).join(", ");
-        const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
-        sql += ` AND ${targetPkCol} IN (${placeholders})`;
-        params.push(...childIds);
+    let sql = `UPDATE ${dialect.tableRef(targetTable)} SET ${dialect.quoteIdentifier(fkCol.sqlName)} = NULL WHERE ${dialect.quoteIdentifier(fkCol.sqlName)} = ${dialect.placeholder(1)}`;
+    if (childPks && childPks.length > 0) {
+        const predicate = sqlPkPredicate(dialect, targetTable, targetIndex, childPks, 2);
+        sql += ` AND ${predicate.sql}`;
+        params.push(...predicate.params);
     }
     await runQuery(executor, runtime, { operation: "update", tableAccessor: relation.targetAccessor }, sql, params);
 }
-async function setInverseMany(executor, runtime, relation, parentId, childIds) {
+async function setInverseMany(executor, runtime, relation, parentId, childPks, parentTable, parentRow) {
     await disconnectInverseMany(executor, runtime, relation, parentId, undefined);
-    await connectInverseMany(executor, runtime, relation, parentId, childIds);
+    await connectInverseMany(executor, runtime, relation, parentId, childPks, parentTable, parentRow);
 }
-async function deleteInverseManyChildren(executor, runtime, relation, parentId, childIds) {
+async function deleteInverseManyChildren(executor, runtime, relation, parentId, childPks) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const targetTable = manifest.tables[relation.targetAccessor];
     if (!targetTable)
         return;
-    const fkCol = childFkColumnMeta(targetTable, relation, getTableIndex(runtime.tableIndex, targetTable.accessor));
-    const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
+    const targetIndex = getTableIndex(runtime.tableIndex, targetTable.accessor);
+    const fkCol = childFkColumnMeta(targetTable, relation, targetIndex);
     const params = [parentId];
-    let sql = `DELETE FROM ${tableRef(targetTable)} WHERE ${quoteIdentifier(fkCol.sqlName)} = $1`;
-    if (childIds && childIds.length > 0) {
-        const placeholders = childIds.map((_, i) => `$${i + 2}`).join(", ");
-        sql += ` AND ${targetPkCol} IN (${placeholders})`;
-        params.push(...childIds);
+    let sql = `DELETE FROM ${dialect.tableRef(targetTable)} WHERE ${dialect.quoteIdentifier(fkCol.sqlName)} = ${dialect.placeholder(1)}`;
+    if (childPks && childPks.length > 0) {
+        const predicate = sqlPkPredicate(dialect, targetTable, targetIndex, childPks, 2);
+        sql += ` AND ${predicate.sql}`;
+        params.push(...predicate.params);
     }
     await runQuery(executor, runtime, { operation: "delete", tableAccessor: relation.targetAccessor }, sql, params);
 }
 async function listM2MLinkedIds(executor, runtime, m2m, parentAccessor, parentId) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const throughTable = manifest.tables[m2m.throughAccessor];
     if (!throughTable)
@@ -272,10 +399,11 @@ async function listM2MLinkedIds(executor, runtime, m2m, parentAccessor, parentId
     const otherCol = columnBySqlName(throughIndex, throughTable, otherFkCol);
     if (!parentCol || !otherCol)
         return [];
-    const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: throughTable.accessor }, `SELECT ${quoteIdentifier(otherCol.sqlName)} FROM ${tableRef(throughTable)} WHERE ${quoteIdentifier(parentCol.sqlName)} = $1`, [parentId]);
+    const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: throughTable.accessor }, `SELECT ${dialect.quoteIdentifier(otherCol.sqlName)} FROM ${dialect.tableRef(throughTable)} WHERE ${dialect.quoteIdentifier(parentCol.sqlName)} = ${dialect.placeholder(1)}`, [parentId]);
     return rows.map((row) => String(row[otherCol.sqlName] ?? row[otherCol.tsName]));
 }
-async function deleteM2MRelated(executor, runtime, m2m, tableAccessor, parentId, relatedIds) {
+async function deleteM2MRelated(executor, runtime, m2m, tableAccessor, parentId, relatedIds, targetPks) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const isLeft = m2m.leftAccessor === tableAccessor;
     const targetAccessor = isLeft ? m2m.rightAccessor : m2m.leftAccessor;
@@ -287,29 +415,59 @@ async function deleteM2MRelated(executor, runtime, m2m, tableAccessor, parentId,
     if (ids.length === 0)
         return;
     await deleteJunctionRows(executor, runtime, m2m, tableAccessor, parentId, ids);
-    const targetPkCol = quoteIdentifier(primaryKeySqlName(targetTable));
-    const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
-    await runQuery(executor, runtime, { operation: "delete", tableAccessor: targetAccessor }, `DELETE FROM ${tableRef(targetTable)} WHERE ${targetPkCol} IN (${placeholders})`, ids);
+    const targetIndex = getTableIndex(runtime.tableIndex, targetAccessor);
+    if (targetPks && targetPks.length > 0) {
+        const predicate = sqlPkPredicate(dialect, targetTable, targetIndex, targetPks, 1);
+        await runQuery(executor, runtime, { operation: "delete", tableAccessor: targetAccessor }, `DELETE FROM ${dialect.tableRef(targetTable)} WHERE ${predicate.sql}`, predicate.params);
+        return;
+    }
+    const targetPkCol = dialect.quoteIdentifier(primaryKeySqlName(targetTable));
+    const placeholders = joinPlaceholders(dialect, ids.length);
+    await runQuery(executor, runtime, { operation: "delete", tableAccessor: targetAccessor }, `DELETE FROM ${dialect.tableRef(targetTable)} WHERE ${targetPkCol} IN (${placeholders})`, ids);
+}
+function assertExclusiveConnectOrCreate(value, relationName) {
+    if (!("connectOrCreate" in value))
+        return;
+    if ("connect" in value || "create" in value) {
+        compileError(`Relation "${relationName}" cannot mix connectOrCreate with connect or create`, { code: QueryErrorCode.invalid_nested_write });
+    }
 }
 async function executeToOneWrite(executor, runtime, table, scalarData, relationName, value, runCreate) {
     const { manifest } = runtime;
     const tableIndex = getTableIndex(runtime.tableIndex, table.accessor);
     const rel = findRelation(table, relationName, tableIndex);
-    if (!rel || rel.cardinality !== "one")
+    if (rel?.cardinality !== "one")
+        return;
+    const targetTable = manifest.tables[rel.targetAccessor];
+    if (!targetTable)
+        compileError(`Unknown table: ${rel.targetAccessor}`);
+    const targetIndex = getTableIndex(runtime.tableIndex, rel.targetAccessor);
+    assertExclusiveConnectOrCreate(value, relationName);
+    if ("connectOrCreate" in value) {
+        const item = value.connectOrCreate;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            compileError(`Relation "${relationName}" connectOrCreate requires { where, create }`, { code: QueryErrorCode.invalid_nested_write });
+        }
+        const { record } = await findOrCreateRecord(executor, runtime, rel.targetAccessor, {
+            where: item.where,
+            create: item.create,
+        });
+        assignOutgoingFkScalars(scalarData, rel, targetTable, targetIndex, record);
         return;
+    }
     if ("connect" in value) {
-        const ids = normalizeConnectIds(runtime, rel.targetAccessor, value.connect);
-        const id = ids[0];
-        if (id === undefined) {
+        const pks = normalizeConnectPks(runtime, rel.targetAccessor, value.connect);
+        const pk = pks[0];
+        if (pk === undefined) {
             compileError(`Relation connect requires a primary key for table "${rel.targetAccessor}"`, {
                 code: QueryErrorCode.missing_primary_key,
                 tableAccessor: rel.targetAccessor,
             });
         }
-        if (ids.length > 1) {
+        if (pks.length > 1) {
             compileError(`Cannot connect more than one record to to-one relation ${relationName}`);
         }
-        scalarData[rel.fkColumn] = id;
+        assignOutgoingFkScalars(scalarData, rel, targetTable, targetIndex, pk);
         return;
     }
     if ("disconnect" in value) {
@@ -318,17 +476,14 @@ async function executeToOneWrite(executor, runtime, table, scalarData, relationN
         if (fkCol && !fkCol.nullable) {
             compileError(`Cannot disconnect relation ${relationName}: FK column is not nullable`);
         }
-        scalarData[rel.fkColumn] = null;
+        assignOutgoingFkScalars(scalarData, rel, targetTable, targetIndex, {}, true);
         return;
     }
     if ("create" in value) {
         const created = await runCreate(executor, runtime, rel.targetAccessor, {
-            data: value["create"],
+            data: value.create,
         });
-        const targetTable = manifest.tables[rel.targetAccessor];
-        if (!targetTable)
-            compileError(`Unknown table: ${rel.targetAccessor}`);
-        scalarData[rel.fkColumn] = rowScalarPkValue(created, targetTable);
+        assignOutgoingFkScalars(scalarData, rel, targetTable, targetIndex, created);
     }
 }
 export async function applyToOnePreWrites(executor, runtime, table, scalarData, relationWrites, runCreate) {
@@ -336,7 +491,7 @@ export async function applyToOnePreWrites(executor, runtime, table, scalarData,
         return;
     for (const write of relationWrites) {
         const rel = findRelation(table, write.relationName);
-        if (!rel || rel.cardinality !== "one" || !tableOwnsFkColumn(table, rel))
+        if (rel?.cardinality !== "one" || !tableOwnsFkColumn(table, rel))
             continue;
         await executeToOneWrite(executor, runtime, table, scalarData, write.relationName, write.value, runCreate);
     }
@@ -349,27 +504,27 @@ async function executeM2MWrite(executor, runtime, tableAccessor, parentId, relat
     const isLeft = m2m.leftAccessor === tableAccessor;
     const targetAccessor = isLeft ? m2m.rightAccessor : m2m.leftAccessor;
     if ("delete" in value) {
-        const del = value["delete"];
+        const del = value.delete;
         if (del === true) {
             await deleteM2MRelated(executor, runtime, m2m, tableAccessor, parentId, undefined);
         }
         else {
-            const ids = normalizeConnectIds(runtime, targetAccessor, del);
-            await deleteM2MRelated(executor, runtime, m2m, tableAccessor, parentId, ids);
+            const { pks, ids } = m2mConnectFkValues(runtime, m2m, tableAccessor, targetAccessor, del);
+            await deleteM2MRelated(executor, runtime, m2m, tableAccessor, parentId, ids, pks);
         }
     }
     if ("disconnect" in value) {
-        const disconnect = value["disconnect"];
+        const disconnect = value.disconnect;
         if (disconnect === true) {
             await deleteJunctionRows(executor, runtime, m2m, tableAccessor, parentId);
         }
         else {
-            const ids = normalizeConnectIds(runtime, targetAccessor, disconnect);
+            const { ids } = m2mConnectFkValues(runtime, m2m, tableAccessor, targetAccessor, disconnect);
             await deleteJunctionRows(executor, runtime, m2m, tableAccessor, parentId, ids);
         }
     }
     if ("set" in value) {
-        const ids = normalizeConnectIds(runtime, targetAccessor, value["set"]);
+        const { ids } = m2mConnectFkValues(runtime, m2m, tableAccessor, targetAccessor, value.set);
         await deleteJunctionRows(executor, runtime, m2m, tableAccessor, parentId);
         if (ids.length > 0) {
             await insertM2MLinks(executor, runtime, m2m, tableAccessor, parentId, ids);
@@ -377,85 +532,88 @@ async function executeM2MWrite(executor, runtime, tableAccessor, parentId, relat
         return;
     }
     if ("connect" in value) {
-        const ids = normalizeConnectIds(runtime, targetAccessor, value["connect"]);
+        const { ids } = m2mConnectFkValues(runtime, m2m, tableAccessor, targetAccessor, value.connect);
         if (ids.length > 0) {
             await insertM2MLinks(executor, runtime, m2m, tableAccessor, parentId, ids);
         }
     }
     if ("connectOrCreate" in value) {
-        const items = value["connectOrCreate"];
-        const ids = await resolveConnectOrCreate(executor, runtime, targetAccessor, items);
+        const items = value.connectOrCreate;
+        const targetTable = requireTable(runtime.manifest, targetAccessor, "select");
+        const targetIndex = getTableIndex(runtime.tableIndex, targetAccessor);
+        const throughFk = m2mOtherThroughColumn(runtime, m2m, tableAccessor);
+        const fkTs = fkTargetTsName(targetTable, targetIndex, undefined, throughFk);
+        const ids = await resolveConnectOrCreate(executor, runtime, targetAccessor, items, fkTs);
         if (ids.length > 0) {
             await insertM2MLinks(executor, runtime, m2m, tableAccessor, parentId, ids);
         }
     }
 }
-async function executeInverseManyWrite(executor, runtime, table, parentId, relationName, value, runCreate) {
+async function executeInverseManyWrite(executor, runtime, table, parentId, relationName, value, runCreate, parentRow) {
     const { manifest } = runtime;
     const rel = findRelation(table, relationName);
-    if (!rel ||
-        rel.cardinality !== "many" ||
+    if (rel?.cardinality !== "many" ||
         findM2M(manifest, table.accessor, relationName)) {
         return;
     }
     if ("delete" in value) {
-        const del = value["delete"];
+        const del = value.delete;
         if (del === true) {
             await deleteInverseManyChildren(executor, runtime, rel, parentId, undefined);
         }
         else {
-            const ids = normalizeConnectIds(runtime, rel.targetAccessor, del);
-            await deleteInverseManyChildren(executor, runtime, rel, parentId, ids);
+            const pks = normalizeConnectPks(runtime, rel.targetAccessor, del);
+            await deleteInverseManyChildren(executor, runtime, rel, parentId, pks);
         }
     }
     if ("disconnect" in value) {
-        const disconnect = value["disconnect"];
+        const disconnect = value.disconnect;
         if (disconnect === true) {
             await disconnectInverseMany(executor, runtime, rel, parentId, undefined);
         }
         else {
-            const ids = normalizeConnectIds(runtime, rel.targetAccessor, disconnect);
-            await disconnectInverseMany(executor, runtime, rel, parentId, ids);
+            const pks = normalizeConnectPks(runtime, rel.targetAccessor, disconnect);
+            await disconnectInverseMany(executor, runtime, rel, parentId, pks);
         }
     }
     if ("set" in value) {
-        const ids = normalizeConnectIds(runtime, rel.targetAccessor, value["set"]);
-        await setInverseMany(executor, runtime, rel, parentId, ids);
+        const pks = normalizeConnectPks(runtime, rel.targetAccessor, value.set);
+        await setInverseMany(executor, runtime, rel, parentId, pks, table, parentRow);
         return;
     }
     if ("connect" in value) {
-        const ids = normalizeConnectIds(runtime, rel.targetAccessor, value["connect"]);
-        await connectInverseMany(executor, runtime, rel, parentId, ids);
+        const pks = normalizeConnectPks(runtime, rel.targetAccessor, value.connect);
+        await connectInverseMany(executor, runtime, rel, parentId, pks, table, parentRow);
     }
     if ("create" in value) {
-        const items = normalizeCreateList(value["create"]);
+        const items = normalizeCreateList(value.create);
         for (const item of items) {
             await runCreate(executor, runtime, rel.targetAccessor, {
                 data: {
                     ...item,
-                    [rel.fkColumn]: parentId,
+                    ...childFkCreatePatch(rel, table, parentRow, parentId),
                 },
             });
         }
     }
 }
-async function executeInverseOneWrite(executor, runtime, table, parentId, relationName, value, runCreate) {
+async function executeInverseOneWrite(executor, runtime, table, parentId, relationName, value, runCreate, parentRow) {
     const { manifest } = runtime;
     const rel = findRelation(table, relationName);
-    if (!rel || rel.cardinality !== "one" || tableOwnsFkColumn(table, rel))
+    if (rel?.cardinality !== "one" || tableOwnsFkColumn(table, rel))
         return;
     const targetTable = manifest.tables[rel.targetAccessor];
     if (!targetTable)
         return;
     const fkCol = childFkColumnMeta(targetTable, rel);
     if ("delete" in value) {
-        const del = value["delete"];
+        const del = value.delete;
         if (del === true) {
             await deleteInverseManyChildren(executor, runtime, rel, parentId, undefined);
         }
         else {
-            const ids = normalizeConnectIds(runtime, rel.targetAccessor, del);
-            await deleteInverseManyChildren(executor, runtime, rel, parentId, ids);
+            const pks = normalizeConnectPks(runtime, rel.targetAccessor, del);
+            await deleteInverseManyChildren(executor, runtime, rel, parentId, pks);
         }
     }
     if ("disconnect" in value) {
@@ -465,26 +623,26 @@ async function executeInverseOneWrite(executor, runtime, table, parentId, relati
         await disconnectInverseMany(executor, runtime, rel, parentId, undefined);
     }
     if ("set" in value) {
-        const ids = normalizeConnectIds(runtime, rel.targetAccessor, value["set"]);
-        const id = ids[0];
-        if (id) {
+        const pks = normalizeConnectPks(runtime, rel.targetAccessor, value.set);
+        const pk = pks[0];
+        if (pk) {
             await disconnectInverseMany(executor, runtime, rel, parentId, undefined);
-            await connectInverseMany(executor, runtime, rel, parentId, [id]);
+            await connectInverseMany(executor, runtime, rel, parentId, [pk], table, parentRow);
         }
         return;
     }
     if ("connect" in value) {
-        const ids = normalizeConnectIds(runtime, rel.targetAccessor, value["connect"]);
-        const id = ids[0];
-        if (!id)
+        const pks = normalizeConnectPks(runtime, rel.targetAccessor, value.connect);
+        const pk = pks[0];
+        if (!pk)
             return;
-        if (ids.length > 1) {
+        if (pks.length > 1) {
             compileError(`Cannot connect more than one record to one-to-one relation ${relationName}`);
         }
-        await connectInverseMany(executor, runtime, rel, parentId, [id]);
+        await connectInverseMany(executor, runtime, rel, parentId, [pk], table, parentRow);
     }
     if ("create" in value) {
-        const items = normalizeCreateList(value["create"]);
+        const items = normalizeCreateList(value.create);
         if (items.length > 1) {
             compileError(`Cannot create more than one record for one-to-one relation ${relationName}`);
         }
@@ -493,13 +651,13 @@ async function executeInverseOneWrite(executor, runtime, table, parentId, relati
             await runCreate(executor, runtime, rel.targetAccessor, {
                 data: {
                     ...item,
-                    [rel.fkColumn]: parentId,
+                    ...childFkCreatePatch(rel, table, parentRow, parentId),
                 },
             });
         }
     }
 }
-export async function executeRelationWrites(executor, runtime, tableAccessor, parentId, relationWrites, runCreate) {
+export async function executeRelationWrites(executor, runtime, tableAccessor, parentId, relationWrites, runCreate, parentRow) {
     const { manifest } = runtime;
     const table = requireTable(manifest, tableAccessor, "select");
     for (const write of relationWrites) {
@@ -512,11 +670,11 @@ export async function executeRelationWrites(executor, runtime, tableAccessor, pa
             continue;
         if (rel.cardinality === "one") {
             if (!tableOwnsFkColumn(table, rel)) {
-                await executeInverseOneWrite(executor, runtime, table, parentId, write.relationName, write.value, runCreate);
+                await executeInverseOneWrite(executor, runtime, table, parentId, write.relationName, write.value, runCreate, parentRow);
             }
             continue;
         }
-        await executeInverseManyWrite(executor, runtime, table, parentId, write.relationName, write.value, runCreate);
+        await executeInverseManyWrite(executor, runtime, table, parentId, write.relationName, write.value, runCreate, parentRow);
     }
 }
 export function hasPostRelationWrites(table, manifest, tableAccessor, relationWrites) {
@@ -539,9 +697,7 @@ export function relationWritesNeedTransaction(table, manifest, tableAccessor, re
     }
     for (const write of relationWrites) {
         const rel = findRelation(table, write.relationName);
-        if (!rel ||
-            rel.cardinality !== "one" ||
-            !tableOwnsFkColumn(table, rel)) {
+        if (rel?.cardinality !== "one" || !tableOwnsFkColumn(table, rel)) {
             continue;
         }
         if (typeof write.value === "object" &&