turbine-orm 0.43.0 → 0.44.0

package/dist/cjs/cli/prisma-resolve.js

@@ -153,7 +153,15 @@ function resolvePrismaSchema(ast, schema, options = {}) {
                 if (c.status === 'resolved' && c.turbineFields)
                     compoundUniques[c.selector] = c.turbineFields;
             }
-            result.map.models[model.name] = { table, accessor, fields, relations, compoundUniques };
+            const clientDefaults = collectClientDefaults(model, fields, resolvedSchema?.tables[table]);
+            result.map.models[model.name] = {
+                table,
+                accessor,
+                fields,
+                relations,
+                compoundUniques,
+                ...(clientDefaults ? { clientDefaults } : {}),
+            };
         }
     }
     // Enums.
@@ -236,6 +244,42 @@ function relationFkColumns(model, field) {
     const fieldsArg = relAttr?.args.find((a) => a.key === 'fields' && a.kind === 'array');
     return fieldsArg?.items?.map((pf) => fieldColumn(model, pf)) ?? null;
 }
+/**
+ * Prisma CLIENT-side defaults for a resolved model: `@default(uuid())` /
+ * `@default(cuid())` / `@updatedAt` are filled by the Prisma client (the
+ * database column typically has NO default), so migrated call sites omit those
+ * fields and a plain insert violates NOT NULL. `@default(now())` is normally a
+ * database default, so it is carried only when the introspected column has no
+ * default. `@updatedAt` is always carried (Prisma touches it on every update
+ * regardless of any database default). Returns undefined when the model has
+ * none, keeping the emitted map byte-identical for unaffected schemas.
+ */
+function collectClientDefaults(model, resolvedFields, tableMeta) {
+    if (!tableMeta)
+        return undefined;
+    const out = {};
+    for (const field of model.fields) {
+        const turbineField = resolvedFields[field.name];
+        if (!turbineField)
+            continue;
+        const col = tableMeta.columns.find((c) => c.field === turbineField || c.name === turbineField);
+        if (field.attrs.some((a) => a.name === 'updatedAt')) {
+            out[field.name] = 'updatedAt';
+            continue;
+        }
+        if (col?.hasDefault)
+            continue; // the database fills it; nothing to emulate
+        const def = field.attrs.find((a) => a.name === 'default');
+        const raw = def?.args.find((a) => a.key === undefined && a.kind === 'raw')?.value ?? '';
+        if (/^uuid\s*\(/.test(raw))
+            out[field.name] = 'uuid';
+        else if (/^cuid\s*\(/.test(raw))
+            out[field.name] = 'cuid';
+        else if (/^now\s*\(\s*\)$/.test(raw))
+            out[field.name] = 'now';
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 /**
  * FK columns for an INVERSE relation field (one carrying no `fields: [...]`),
  * derived by @relation("Name") pairing: the opposing model's same-named field

package/dist/cjs/generate.js

@@ -956,6 +956,9 @@ function generatePrismaMap(map, options) {
         }
         lines.push('      },');
         lines.push(`      compoundUniques: ${serializeStringArrayRecord(model.compoundUniques)},`);
+        if (model.clientDefaults && Object.keys(model.clientDefaults).length > 0) {
+            lines.push(`      clientDefaults: ${serializeStringRecord(model.clientDefaults)},`);
+        }
         lines.push('    },');
     }
     lines.push('  },');

package/dist/cjs/prisma-compat.js

@@ -872,7 +872,118 @@ function prismaPropertyAlias(model) {
  * QueryInterface for this model's table on the active connection (the base pool,
  * or a transaction's connection inside `$transaction(callback)`).
  */
-function makeDelegate(ctx, mm, getQI) {
+// ---------------------------------------------------------------------------
+// Prisma client-side defaults (@default(uuid()/cuid()) / @updatedAt / now())
+// ---------------------------------------------------------------------------
+let cuidCounter = Math.floor(Math.random() * 1296);
+/**
+ * A cuid-shaped id ('c' + timestamp + counter + fingerprint + random, 25
+ * chars): collision-resistant and format-compatible with Prisma's
+ * `@default(cuid())` call sites. Not byte-identical to any specific cuid
+ * library; Prisma treats these as opaque unique strings.
+ */
+function makeCuid() {
+    const ts = Date.now().toString(36);
+    const count = (cuidCounter++ % 1296).toString(36).padStart(2, '0');
+    const rand = () => Math.floor(Math.random() * 36 ** 4)
+        .toString(36)
+        .padStart(4, '0');
+    return `c${ts}${count}${rand()}${rand()}${rand()}`.slice(0, 25);
+}
+function clientDefaultValue(kind) {
+    if (kind === 'uuid')
+        return globalThis.crypto.randomUUID();
+    if (kind === 'cuid')
+        return makeCuid();
+    return new Date();
+}
+/** Fill missing create-side client defaults (uuid / cuid / now / updatedAt), by Prisma field name. */
+function applyCreateDefaults(mm, data) {
+    const cd = mm.clientDefaults;
+    if (!cd || !isPlainObject(data))
+        return data;
+    let out = data;
+    for (const [field, kind] of Object.entries(cd)) {
+        if (out[field] === undefined) {
+            if (out === data)
+                out = { ...data };
+            out[field] = clientDefaultValue(kind);
+        }
+    }
+    return out;
+}
+/** Touch @updatedAt fields on the update side (Prisma sets them on every update). */
+function applyUpdateTouch(mm, data) {
+    const cd = mm.clientDefaults;
+    if (!cd || !isPlainObject(data))
+        return data;
+    let out = data;
+    for (const [field, kind] of Object.entries(cd)) {
+        if (kind === 'updatedAt' && out[field] === undefined) {
+            if (out === data)
+                out = { ...data };
+            out[field] = new Date();
+        }
+    }
+    return out;
+}
+/** Whether TRANSLATED write data carries relation keys (nested-write shapes). */
+function hasNestedKeys(ctx, mm, data) {
+    const rels = ctx.schema.tables[mm.table]?.relations;
+    if (!rels || !isPlainObject(data))
+        return false;
+    return Object.keys(data).some((k) => {
+        if (!Object.hasOwn(rels, k))
+            return false;
+        const v = data[k];
+        return v !== null && typeof v === 'object' && !Array.isArray(v) && !(v instanceof Date);
+    });
+}
+/**
+ * Whether an upsert's translated `where` key values all equal the
+ * corresponding `create` values. When they do (the common Prisma idiom), the
+ * native single-statement ON CONFLICT upsert is semantically identical to
+ * Prisma's lookup-first and stays atomic. When they differ, native upsert
+ * would insert the `create` row even though the `where` row exists, so the
+ * adapter must emulate lookup-first instead.
+ */
+function upsertKeysMatch(t) {
+    const where = t.where;
+    const create = t.create;
+    if (!isPlainObject(where) || !isPlainObject(create))
+        return false;
+    const scalarEq = (a, b) => {
+        if (a instanceof Date || b instanceof Date) {
+            return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+        }
+        return a === b;
+    };
+    for (const [k, v] of Object.entries(where)) {
+        if (v !== null && typeof v === 'object' && !(v instanceof Date)) {
+            // Compound-unique selector object: every member must scalar-match create.
+            if (Array.isArray(v))
+                return false;
+            for (const [mk, mv] of Object.entries(v)) {
+                if (mv !== null && typeof mv === 'object' && !(mv instanceof Date))
+                    return false;
+                if (!scalarEq(mv, create[mk]))
+                    return false;
+            }
+            continue;
+        }
+        if (!scalarEq(v, create[k]))
+            return false;
+    }
+    return true;
+}
+/** Prisma upsert semantics: look up by where; update the found row, else insert create. */
+async function upsertLookupFirst(qi, t) {
+    const existing = await qi.findUnique({ where: t.where });
+    if (existing)
+        return qi.update({ where: t.where, data: t.update });
+    return qi.create({ data: t.create });
+}
+function makeDelegate(ctx, mm, getQI, runInTx) {
     const pe = ctx.options.prismaErrorCodes;
     // Build a lazy Prisma-style promise for one delegate call. Crucially, the
     // Prisma-arg `translate` step runs INSIDE the deferred paths (the run closure
@@ -885,7 +996,27 @@ function makeDelegate(ctx, mm, getQI) {
     // catches the same throw from `batch.build`.
     const defer = (translate, run, batch) => {
         const batchable = batch
-            ? { build: () => batch.build(getQI(), translate()), reshape: batch.reshape }
+            ? {
+                build: () => batch.build(getQI(), translate()),
+                reshape: batch.reshape,
+                nested: () => {
+                    try {
+                        return batch.nested?.(translate()) ?? false;
+                    }
+                    catch {
+                        return false; // let the build path surface the translation error consistently
+                    }
+                },
+                execInTx: async (table) => {
+                    try {
+                        const t = translate();
+                        return batch.execInTx ? await batch.execInTx(table, t) : await run(table(mm.table), t);
+                    }
+                    catch (err) {
+                        throw decorate(err, pe);
+                    }
+                },
+            }
             : undefined;
         return new CompatPromise(async () => {
             try {
@@ -909,14 +1040,20 @@ function makeDelegate(ctx, mm, getQI) {
         findFirstOrThrow: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findFirstOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
         findUniqueOrThrow: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow')), (qi, t) => qi.findUniqueOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
         create: (args) => defer(() => {
-            const t = { data: translateWriteData(ctx, mm, args.data) };
+            const t = { data: translateWriteData(ctx, mm, applyCreateDefaults(mm, args.data)) };
             if (typeof args.timeout === 'number')
                 t.timeout = args.timeout;
             return t;
-        }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildCreate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), {
+            build: (qi, t) => qi.buildCreate(t),
+            reshape: (raw) => reshapeRow(ctx, mm, raw),
+            nested: (t) => hasNestedKeys(ctx, mm, t.data),
+        }),
         createMany: (args) => defer(() => {
             const data = args.data;
-            const rows = Array.isArray(data) ? data.map((d) => translateWriteData(ctx, mm, d)) : [];
+            const rows = Array.isArray(data)
+                ? data.map((d) => translateWriteData(ctx, mm, applyCreateDefaults(mm, d)))
+                : [];
             const t = { data: rows };
             if (args.skipDuplicates)
                 t.skipDuplicates = true;
@@ -924,11 +1061,21 @@ function makeDelegate(ctx, mm, getQI) {
         }, (qi, t) => qi.createMany(t).then((r) => ({ count: r.length })), { build: (qi, t) => qi.buildCreateMany(t), reshape: (raw) => ({ count: raw.length }) }),
         update: (args) => defer(() => {
             const a = requireWhere(args, 'update');
-            return { where: translateWhere(ctx, mm, a.where), data: translateWriteData(ctx, mm, a.data) };
-        }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpdate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+            return {
+                where: translateWhere(ctx, mm, a.where),
+                data: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.data)),
+            };
+        }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), {
+            build: (qi, t) => qi.buildUpdate(t),
+            reshape: (raw) => reshapeRow(ctx, mm, raw),
+            nested: (t) => hasNestedKeys(ctx, mm, t.data),
+        }),
         updateMany: (args) => defer(() => {
             const a = args;
-            const t = { where: translateWhere(ctx, mm, a.where ?? {}), data: translateWriteData(ctx, mm, a.data) };
+            const t = {
+                where: translateWhere(ctx, mm, a.where ?? {}),
+                data: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.data)),
+            };
             if (a.where === undefined)
                 t.allowFullTableScan = true;
             return t;
@@ -948,10 +1095,31 @@ function makeDelegate(ctx, mm, getQI) {
             const a = requireWhere(args, 'upsert');
             return {
                 where: translateWhere(ctx, mm, a.where),
-                create: translateWriteData(ctx, mm, a.create),
-                update: translateWriteData(ctx, mm, a.update),
+                create: translateWriteData(ctx, mm, applyCreateDefaults(mm, a.create)),
+                update: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.update)),
             };
-        }, (qi, t) => qi.upsert(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpsert(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        }, (qi, t) => {
+            // Native ON CONFLICT upsert is only Prisma-equivalent when the where
+            // key values equal the create values AND no nested write data is
+            // present; otherwise emulate Prisma's lookup-first atomically.
+            if (upsertKeysMatch(t) && !hasNestedKeys(ctx, mm, t.create) && !hasNestedKeys(ctx, mm, t.update)) {
+                return qi.upsert(t).then((r) => reshapeRow(ctx, mm, r));
+            }
+            return runInTx(async (table) => {
+                const row = await upsertLookupFirst(table(mm.table), t);
+                return reshapeRow(ctx, mm, row);
+            });
+        }, {
+            build: (qi, t) => qi.buildUpsert(t),
+            reshape: (raw) => reshapeRow(ctx, mm, raw),
+            nested: (t) => !upsertKeysMatch(t) || hasNestedKeys(ctx, mm, t.create) || hasNestedKeys(ctx, mm, t.update),
+            execInTx: async (table, t) => {
+                if (upsertKeysMatch(t) && !hasNestedKeys(ctx, mm, t.create) && !hasNestedKeys(ctx, mm, t.update)) {
+                    return reshapeRow(ctx, mm, await table(mm.table).upsert(t));
+                }
+                return reshapeRow(ctx, mm, await upsertLookupFirst(table(mm.table), t));
+            },
+        }),
         count: (args = {}) => defer(() => {
             const t = {};
             if (args.where !== undefined)
@@ -1046,7 +1214,7 @@ function createPrismaCompatClient(client, map, options = {}) {
     // Delegates bound to the base client (each call reads db.table(...) lazily).
     const delegates = new Map();
     for (const [prismaModel, mm] of Object.entries(map.models)) {
-        delegates.set(prismaModel, makeDelegate(ctx, mm, () => db.table(mm.table)));
+        delegates.set(prismaModel, makeDelegate(ctx, mm, () => db.table(mm.table), (fn) => db.$transaction((tx) => fn((n) => tx.table(n)))));
     }
     const ph = placeholderOf(db);
     const runRaw = async (text, params) => {
@@ -1073,6 +1241,18 @@ function createPrismaCompatClient(client, map, options = {}) {
                             }
                             return b;
                         });
+                        // Nested write data (or a lookup-first upsert) cannot run as a
+                        // single deferred statement. Prisma's array form still supports
+                        // those, so fall back to running the WHOLE array sequentially
+                        // inside one transaction; ordering and atomicity are preserved.
+                        if (batchables.some((b) => b.nested())) {
+                            return await db.$transaction(async (tx) => {
+                                const out = [];
+                                for (const b of batchables)
+                                    out.push(await b.execInTx((n) => tx.table(n)));
+                                return out;
+                            }, txOptions);
+                        }
                         const deferreds = batchables.map((b) => b.build());
                         const results = (await db.$transaction(deferreds));
                         return results.map((raw, i) => batchables[i].reshape(raw));
@@ -1087,7 +1267,7 @@ function createPrismaCompatClient(client, map, options = {}) {
             return db.$transaction((tx) => {
                 const txDelegates = {};
                 for (const [prismaModel, mm] of Object.entries(map.models)) {
-                    txDelegates[prismaModel] = makeDelegate(ctx, mm, () => tx.table(mm.table));
+                    txDelegates[prismaModel] = makeDelegate(ctx, mm, () => tx.table(mm.table), (fn) => fn((n) => tx.table(n)));
                     const alias = prismaPropertyAlias(prismaModel);
                     if (alias && !(alias in map.models) && !(alias in txDelegates)) {
                         txDelegates[alias] = txDelegates[prismaModel];

package/dist/cli/prisma-resolve.js

@@ -148,7 +148,15 @@ export function resolvePrismaSchema(ast, schema, options = {}) {
                 if (c.status === 'resolved' && c.turbineFields)
                     compoundUniques[c.selector] = c.turbineFields;
             }
-            result.map.models[model.name] = { table, accessor, fields, relations, compoundUniques };
+            const clientDefaults = collectClientDefaults(model, fields, resolvedSchema?.tables[table]);
+            result.map.models[model.name] = {
+                table,
+                accessor,
+                fields,
+                relations,
+                compoundUniques,
+                ...(clientDefaults ? { clientDefaults } : {}),
+            };
         }
     }
     // Enums.
@@ -231,6 +239,42 @@ function relationFkColumns(model, field) {
     const fieldsArg = relAttr?.args.find((a) => a.key === 'fields' && a.kind === 'array');
     return fieldsArg?.items?.map((pf) => fieldColumn(model, pf)) ?? null;
 }
+/**
+ * Prisma CLIENT-side defaults for a resolved model: `@default(uuid())` /
+ * `@default(cuid())` / `@updatedAt` are filled by the Prisma client (the
+ * database column typically has NO default), so migrated call sites omit those
+ * fields and a plain insert violates NOT NULL. `@default(now())` is normally a
+ * database default, so it is carried only when the introspected column has no
+ * default. `@updatedAt` is always carried (Prisma touches it on every update
+ * regardless of any database default). Returns undefined when the model has
+ * none, keeping the emitted map byte-identical for unaffected schemas.
+ */
+function collectClientDefaults(model, resolvedFields, tableMeta) {
+    if (!tableMeta)
+        return undefined;
+    const out = {};
+    for (const field of model.fields) {
+        const turbineField = resolvedFields[field.name];
+        if (!turbineField)
+            continue;
+        const col = tableMeta.columns.find((c) => c.field === turbineField || c.name === turbineField);
+        if (field.attrs.some((a) => a.name === 'updatedAt')) {
+            out[field.name] = 'updatedAt';
+            continue;
+        }
+        if (col?.hasDefault)
+            continue; // the database fills it; nothing to emulate
+        const def = field.attrs.find((a) => a.name === 'default');
+        const raw = def?.args.find((a) => a.key === undefined && a.kind === 'raw')?.value ?? '';
+        if (/^uuid\s*\(/.test(raw))
+            out[field.name] = 'uuid';
+        else if (/^cuid\s*\(/.test(raw))
+            out[field.name] = 'cuid';
+        else if (/^now\s*\(\s*\)$/.test(raw))
+            out[field.name] = 'now';
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 /**
  * FK columns for an INVERSE relation field (one carrying no `fields: [...]`),
  * derived by @relation("Name") pairing: the opposing model's same-named field

package/dist/generate.js

@@ -944,6 +944,9 @@ export function generatePrismaMap(map, options) {
         }
         lines.push('      },');
         lines.push(`      compoundUniques: ${serializeStringArrayRecord(model.compoundUniques)},`);
+        if (model.clientDefaults && Object.keys(model.clientDefaults).length > 0) {
+            lines.push(`      clientDefaults: ${serializeStringRecord(model.clientDefaults)},`);
+        }
         lines.push('    },');
     }
     lines.push('  },');

package/dist/prisma-compat.js

@@ -868,7 +868,118 @@ function prismaPropertyAlias(model) {
  * QueryInterface for this model's table on the active connection (the base pool,
  * or a transaction's connection inside `$transaction(callback)`).
  */
-function makeDelegate(ctx, mm, getQI) {
+// ---------------------------------------------------------------------------
+// Prisma client-side defaults (@default(uuid()/cuid()) / @updatedAt / now())
+// ---------------------------------------------------------------------------
+let cuidCounter = Math.floor(Math.random() * 1296);
+/**
+ * A cuid-shaped id ('c' + timestamp + counter + fingerprint + random, 25
+ * chars): collision-resistant and format-compatible with Prisma's
+ * `@default(cuid())` call sites. Not byte-identical to any specific cuid
+ * library; Prisma treats these as opaque unique strings.
+ */
+function makeCuid() {
+    const ts = Date.now().toString(36);
+    const count = (cuidCounter++ % 1296).toString(36).padStart(2, '0');
+    const rand = () => Math.floor(Math.random() * 36 ** 4)
+        .toString(36)
+        .padStart(4, '0');
+    return `c${ts}${count}${rand()}${rand()}${rand()}`.slice(0, 25);
+}
+function clientDefaultValue(kind) {
+    if (kind === 'uuid')
+        return globalThis.crypto.randomUUID();
+    if (kind === 'cuid')
+        return makeCuid();
+    return new Date();
+}
+/** Fill missing create-side client defaults (uuid / cuid / now / updatedAt), by Prisma field name. */
+function applyCreateDefaults(mm, data) {
+    const cd = mm.clientDefaults;
+    if (!cd || !isPlainObject(data))
+        return data;
+    let out = data;
+    for (const [field, kind] of Object.entries(cd)) {
+        if (out[field] === undefined) {
+            if (out === data)
+                out = { ...data };
+            out[field] = clientDefaultValue(kind);
+        }
+    }
+    return out;
+}
+/** Touch @updatedAt fields on the update side (Prisma sets them on every update). */
+function applyUpdateTouch(mm, data) {
+    const cd = mm.clientDefaults;
+    if (!cd || !isPlainObject(data))
+        return data;
+    let out = data;
+    for (const [field, kind] of Object.entries(cd)) {
+        if (kind === 'updatedAt' && out[field] === undefined) {
+            if (out === data)
+                out = { ...data };
+            out[field] = new Date();
+        }
+    }
+    return out;
+}
+/** Whether TRANSLATED write data carries relation keys (nested-write shapes). */
+function hasNestedKeys(ctx, mm, data) {
+    const rels = ctx.schema.tables[mm.table]?.relations;
+    if (!rels || !isPlainObject(data))
+        return false;
+    return Object.keys(data).some((k) => {
+        if (!Object.hasOwn(rels, k))
+            return false;
+        const v = data[k];
+        return v !== null && typeof v === 'object' && !Array.isArray(v) && !(v instanceof Date);
+    });
+}
+/**
+ * Whether an upsert's translated `where` key values all equal the
+ * corresponding `create` values. When they do (the common Prisma idiom), the
+ * native single-statement ON CONFLICT upsert is semantically identical to
+ * Prisma's lookup-first and stays atomic. When they differ, native upsert
+ * would insert the `create` row even though the `where` row exists, so the
+ * adapter must emulate lookup-first instead.
+ */
+function upsertKeysMatch(t) {
+    const where = t.where;
+    const create = t.create;
+    if (!isPlainObject(where) || !isPlainObject(create))
+        return false;
+    const scalarEq = (a, b) => {
+        if (a instanceof Date || b instanceof Date) {
+            return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+        }
+        return a === b;
+    };
+    for (const [k, v] of Object.entries(where)) {
+        if (v !== null && typeof v === 'object' && !(v instanceof Date)) {
+            // Compound-unique selector object: every member must scalar-match create.
+            if (Array.isArray(v))
+                return false;
+            for (const [mk, mv] of Object.entries(v)) {
+                if (mv !== null && typeof mv === 'object' && !(mv instanceof Date))
+                    return false;
+                if (!scalarEq(mv, create[mk]))
+                    return false;
+            }
+            continue;
+        }
+        if (!scalarEq(v, create[k]))
+            return false;
+    }
+    return true;
+}
+/** Prisma upsert semantics: look up by where; update the found row, else insert create. */
+async function upsertLookupFirst(qi, t) {
+    const existing = await qi.findUnique({ where: t.where });
+    if (existing)
+        return qi.update({ where: t.where, data: t.update });
+    return qi.create({ data: t.create });
+}
+function makeDelegate(ctx, mm, getQI, runInTx) {
     const pe = ctx.options.prismaErrorCodes;
     // Build a lazy Prisma-style promise for one delegate call. Crucially, the
     // Prisma-arg `translate` step runs INSIDE the deferred paths (the run closure
@@ -881,7 +992,27 @@ function makeDelegate(ctx, mm, getQI) {
     // catches the same throw from `batch.build`.
     const defer = (translate, run, batch) => {
         const batchable = batch
-            ? { build: () => batch.build(getQI(), translate()), reshape: batch.reshape }
+            ? {
+                build: () => batch.build(getQI(), translate()),
+                reshape: batch.reshape,
+                nested: () => {
+                    try {
+                        return batch.nested?.(translate()) ?? false;
+                    }
+                    catch {
+                        return false; // let the build path surface the translation error consistently
+                    }
+                },
+                execInTx: async (table) => {
+                    try {
+                        const t = translate();
+                        return batch.execInTx ? await batch.execInTx(table, t) : await run(table(mm.table), t);
+                    }
+                    catch (err) {
+                        throw decorate(err, pe);
+                    }
+                },
+            }
             : undefined;
         return new CompatPromise(async () => {
             try {
@@ -905,14 +1036,20 @@ function makeDelegate(ctx, mm, getQI) {
         findFirstOrThrow: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findFirstOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
         findUniqueOrThrow: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow')), (qi, t) => qi.findUniqueOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
         create: (args) => defer(() => {
-            const t = { data: translateWriteData(ctx, mm, args.data) };
+            const t = { data: translateWriteData(ctx, mm, applyCreateDefaults(mm, args.data)) };
             if (typeof args.timeout === 'number')
                 t.timeout = args.timeout;
             return t;
-        }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildCreate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), {
+            build: (qi, t) => qi.buildCreate(t),
+            reshape: (raw) => reshapeRow(ctx, mm, raw),
+            nested: (t) => hasNestedKeys(ctx, mm, t.data),
+        }),
         createMany: (args) => defer(() => {
             const data = args.data;
-            const rows = Array.isArray(data) ? data.map((d) => translateWriteData(ctx, mm, d)) : [];
+            const rows = Array.isArray(data)
+                ? data.map((d) => translateWriteData(ctx, mm, applyCreateDefaults(mm, d)))
+                : [];
             const t = { data: rows };
             if (args.skipDuplicates)
                 t.skipDuplicates = true;
@@ -920,11 +1057,21 @@ function makeDelegate(ctx, mm, getQI) {
         }, (qi, t) => qi.createMany(t).then((r) => ({ count: r.length })), { build: (qi, t) => qi.buildCreateMany(t), reshape: (raw) => ({ count: raw.length }) }),
         update: (args) => defer(() => {
             const a = requireWhere(args, 'update');
-            return { where: translateWhere(ctx, mm, a.where), data: translateWriteData(ctx, mm, a.data) };
-        }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpdate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+            return {
+                where: translateWhere(ctx, mm, a.where),
+                data: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.data)),
+            };
+        }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), {
+            build: (qi, t) => qi.buildUpdate(t),
+            reshape: (raw) => reshapeRow(ctx, mm, raw),
+            nested: (t) => hasNestedKeys(ctx, mm, t.data),
+        }),
         updateMany: (args) => defer(() => {
             const a = args;
-            const t = { where: translateWhere(ctx, mm, a.where ?? {}), data: translateWriteData(ctx, mm, a.data) };
+            const t = {
+                where: translateWhere(ctx, mm, a.where ?? {}),
+                data: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.data)),
+            };
             if (a.where === undefined)
                 t.allowFullTableScan = true;
             return t;
@@ -944,10 +1091,31 @@ function makeDelegate(ctx, mm, getQI) {
             const a = requireWhere(args, 'upsert');
             return {
                 where: translateWhere(ctx, mm, a.where),
-                create: translateWriteData(ctx, mm, a.create),
-                update: translateWriteData(ctx, mm, a.update),
+                create: translateWriteData(ctx, mm, applyCreateDefaults(mm, a.create)),
+                update: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.update)),
             };
-        }, (qi, t) => qi.upsert(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpsert(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        }, (qi, t) => {
+            // Native ON CONFLICT upsert is only Prisma-equivalent when the where
+            // key values equal the create values AND no nested write data is
+            // present; otherwise emulate Prisma's lookup-first atomically.
+            if (upsertKeysMatch(t) && !hasNestedKeys(ctx, mm, t.create) && !hasNestedKeys(ctx, mm, t.update)) {
+                return qi.upsert(t).then((r) => reshapeRow(ctx, mm, r));
+            }
+            return runInTx(async (table) => {
+                const row = await upsertLookupFirst(table(mm.table), t);
+                return reshapeRow(ctx, mm, row);
+            });
+        }, {
+            build: (qi, t) => qi.buildUpsert(t),
+            reshape: (raw) => reshapeRow(ctx, mm, raw),
+            nested: (t) => !upsertKeysMatch(t) || hasNestedKeys(ctx, mm, t.create) || hasNestedKeys(ctx, mm, t.update),
+            execInTx: async (table, t) => {
+                if (upsertKeysMatch(t) && !hasNestedKeys(ctx, mm, t.create) && !hasNestedKeys(ctx, mm, t.update)) {
+                    return reshapeRow(ctx, mm, await table(mm.table).upsert(t));
+                }
+                return reshapeRow(ctx, mm, await upsertLookupFirst(table(mm.table), t));
+            },
+        }),
         count: (args = {}) => defer(() => {
             const t = {};
             if (args.where !== undefined)
@@ -1042,7 +1210,7 @@ export function createPrismaCompatClient(client, map, options = {}) {
     // Delegates bound to the base client (each call reads db.table(...) lazily).
     const delegates = new Map();
     for (const [prismaModel, mm] of Object.entries(map.models)) {
-        delegates.set(prismaModel, makeDelegate(ctx, mm, () => db.table(mm.table)));
+        delegates.set(prismaModel, makeDelegate(ctx, mm, () => db.table(mm.table), (fn) => db.$transaction((tx) => fn((n) => tx.table(n)))));
     }
     const ph = placeholderOf(db);
     const runRaw = async (text, params) => {
@@ -1069,6 +1237,18 @@ export function createPrismaCompatClient(client, map, options = {}) {
                             }
                             return b;
                         });
+                        // Nested write data (or a lookup-first upsert) cannot run as a
+                        // single deferred statement. Prisma's array form still supports
+                        // those, so fall back to running the WHOLE array sequentially
+                        // inside one transaction; ordering and atomicity are preserved.
+                        if (batchables.some((b) => b.nested())) {
+                            return await db.$transaction(async (tx) => {
+                                const out = [];
+                                for (const b of batchables)
+                                    out.push(await b.execInTx((n) => tx.table(n)));
+                                return out;
+                            }, txOptions);
+                        }
                         const deferreds = batchables.map((b) => b.build());
                         const results = (await db.$transaction(deferreds));
                         return results.map((raw, i) => batchables[i].reshape(raw));
@@ -1083,7 +1263,7 @@ export function createPrismaCompatClient(client, map, options = {}) {
             return db.$transaction((tx) => {
                 const txDelegates = {};
                 for (const [prismaModel, mm] of Object.entries(map.models)) {
-                    txDelegates[prismaModel] = makeDelegate(ctx, mm, () => tx.table(mm.table));
+                    txDelegates[prismaModel] = makeDelegate(ctx, mm, () => tx.table(mm.table), (fn) => fn((n) => tx.table(n)));
                     const alias = prismaPropertyAlias(prismaModel);
                     if (alias && !(alias in map.models) && !(alias in txDelegates)) {
                         txDelegates[alias] = txDelegates[prismaModel];

package/dist/schema.d.ts

@@ -297,6 +297,17 @@ export interface PrismaModelMap {
      * the core `findUnique`-family derivation cannot know.
      */
     compoundUniques: Record<string, string[]>;
+    /**
+     * Prisma CLIENT-side default per Prisma field name. Prisma's
+     * `@default(uuid())` / `@default(cuid())` / `@updatedAt` (and `@default(now())`
+     * when the migration left no database default) are filled by the Prisma
+     * client, not the database, so the columns commonly have NO db default and a
+     * Prisma call site omits them. The compat adapter fills these on create
+     * (`uuid` / `cuid` / `now`) and touches `updatedAt` fields on
+     * update/updateMany/upsert, exactly like Prisma. Emitted by
+     * `migrate-from-prisma` only for columns the database does not default.
+     */
+    clientDefaults?: Record<string, 'uuid' | 'cuid' | 'now' | 'updatedAt'>;
 }
 /** A resolved Prisma relation field → Turbine relation. */
 export interface PrismaRelationMap {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {