@vibeorm/runtime 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/index.js

@@ -10,8 +10,31 @@ function toSqlExecutor(params) {
     return result.rows;
   };
 }
+// packages/runtime/src/db-now.ts
+import { VibeError } from "@vibeorm/schema";
+function dbNow(options) {
+  const offset = options?.plusSeconds ?? 0;
+  if (typeof offset !== "number" || !Number.isFinite(offset)) {
+    throw new VibeError({
+      code: "VIBE_VALIDATION",
+      message: `dbNow plusSeconds must be a finite number of seconds (fractional is fine), got ${String(offset)}`,
+      meta: { plusSeconds: offset }
+    });
+  }
+  return { __vibeDbNow: true, offsetSeconds: offset };
+}
+function isDbNow(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes("__vibeDbNow") || !keys.includes("offsetSeconds")) {
+    return false;
+  }
+  const candidate = value;
+  return candidate.__vibeDbNow === true && typeof candidate.offsetSeconds === "number" && Number.isInteger(candidate.offsetSeconds);
+}
 // packages/runtime/src/model-meta.ts
-import { VibeError, isEnumType, validateComputedConfig } from "@vibeorm/schema";
+import { VibeError as VibeError2, isEnumType, validateComputedConfig } from "@vibeorm/schema";
 function toClientName(params) {
   const { name } = params;
   if (name.length === 0)
@@ -132,7 +155,7 @@ function buildModelMeta(params) {
     for (const name of model.primaryKey.fields) {
       const field = fieldByName.get(name);
       if (field === undefined) {
-        throw new VibeError({
+        throw new VibeError2({
           code: "VIBE_SCHEMA_INVALID",
           message: `model "${model.name}" declares composite primary-key field "${name}", which does not exist`,
           meta: { model: model.name, field: name }
@@ -144,26 +167,45 @@ function buildModelMeta(params) {
     primaryKey.push(...fields.filter((field) => field.isId));
   }
   const compoundUniques = new Map;
-  const addCompound = (names) => {
-    if (names.length < 2)
-      return;
-    const key = names.join("_");
-    if (compoundUniques.has(key))
-      return;
+  const singleIndexUniques = [];
+  const resolveFields = (names) => {
     const resolved = [];
     for (const name of names) {
       const field = fieldByName.get(name);
       if (field === undefined)
-        return;
+        return null;
       resolved.push(field);
     }
-    compoundUniques.set(key, resolved);
+    return resolved;
+  };
+  const addCompound = (names, nullsNotDistinct) => {
+    if (names.length < 2)
+      return;
+    const key = names.join("_");
+    if (compoundUniques.has(key))
+      return;
+    const resolved = resolveFields(names);
+    if (resolved === null)
+      return;
+    compoundUniques.set(key, { fields: resolved, nullsNotDistinct });
   };
   if (primaryKey.length > 1)
-    addCompound(primaryKey.map((field) => field.name));
+    addCompound(primaryKey.map((field) => field.name), false);
   for (const index of model.indexes) {
-    if (index.kind === "unique")
-      addCompound(index.fields.map((entry) => entry.name));
+    if (index.kind !== "unique" || index.where !== undefined)
+      continue;
+    const names = index.fields.map((entry) => entry.name);
+    const nullsNotDistinct = index.nullsNotDistinct === true;
+    if (names.length === 1) {
+      const field = resolveFields(names)?.[0];
+      if (field === undefined || field.isId || field.isUnique)
+        continue;
+      if (singleIndexUniques.some((entry) => entry.fields[0]?.name === field.name))
+        continue;
+      singleIndexUniques.push({ fields: [field], nullsNotDistinct });
+    } else {
+      addCompound(names, nullsNotDistinct);
+    }
   }
   const computedSpecs = params.computed;
   const computed = computedSpecs === undefined || Object.keys(computedSpecs).length === 0 ? null : new Map(Object.entries(computedSpecs).map(([name, spec]) => [
@@ -180,6 +222,7 @@ function buildModelMeta(params) {
     primaryKey,
     uniqueFields: fields.filter((field) => field.isId || field.isUnique),
     compoundUniques,
+    singleIndexUniques,
     relations: model.relations,
     relationByName: new Map(model.relations.map((relation) => [relation.name, relation])),
     isView: model.isView,
@@ -210,7 +253,7 @@ function getModelMeta(params) {
   const { meta, model } = params;
   const found = meta.modelByName.get(model);
   if (found === undefined) {
-    throw new VibeError({
+    throw new VibeError2({
       code: "VIBE_VALIDATION",
       message: `unknown model "${model}"`,
       meta: { model, known: [...new Set(meta.models.map((entry) => entry.name))] }
@@ -223,20 +266,20 @@ function getFieldMeta(params) {
   const found = model.fieldByName.get(field);
   if (found === undefined) {
     if (model.computed !== null && model.computed.has(field)) {
-      throw new VibeError({
+      throw new VibeError2({
         code: "VIBE_VALIDATION",
         message: `"${field}" on model "${model.name}" is a computed field \u2014 computed fields appear in results (select/omit) only, not in ${context}`,
         meta: { model: model.name, field, context, computed: true }
       });
     }
     if (model.relationByName.has(field)) {
-      throw new VibeError({
+      throw new VibeError2({
         code: "VIBE_VALIDATION",
         message: `"${field}" on model "${model.name}" is a relation \u2014 not valid in ${context} here (relation writes use nested-write verbs, relation reads use select/include)`,
         meta: { model: model.name, field, context }
       });
     }
-    throw new VibeError({
+    throw new VibeError2({
       code: "VIBE_VALIDATION",
       message: `unknown field "${field}" on model "${model.name}" in ${context}`,
       meta: { model: model.name, field, context }
@@ -245,7 +288,7 @@ function getFieldMeta(params) {
   return found;
 }
 // packages/runtime/src/codecs.ts
-import { VibeError as VibeError2, isEnumType as isEnumType2 } from "@vibeorm/schema";
+import { VibeError as VibeError3, isEnumType as isEnumType2 } from "@vibeorm/schema";
 import { DIALECT_CODECS, decodeIsNoop } from "@vibeorm/sql";
 import {
   DIALECT_CODECS as DIALECT_CODECS2,
@@ -341,7 +384,7 @@ var DECIMAL_LITERAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
 function toRealNumber(params) {
   const { field, value } = params;
   const refuse = () => {
-    throw new VibeError2({
+    throw new VibeError3({
       code: "VIBE_VALIDATION",
       message: `"${String(value)}" is not a numeric value for the Decimal field "${field.name}"`,
       meta: { field: field.name, value }
@@ -556,10 +599,11 @@ function decodeAggregateValue(params) {
   return field === null ? value : decodeValue({ dialect, field, value });
 }
 // packages/runtime/src/query-builder.ts
-import { VibeError as VibeError4, unsupportedCapability } from "@vibeorm/schema";
+import { VibeError as VibeError5, unsupportedCapability } from "@vibeorm/schema";
 import {
   SQL_DEFAULT_CELL,
   containsPattern,
+  dbNowMarker,
   endsWithPattern,
   escapeLikePattern,
   jsonParamCell,
@@ -567,9 +611,9 @@ import {
 } from "@vibeorm/sql";
 
 // packages/runtime/src/relation-plan.ts
-import { VibeError as VibeError3, implicitJoinTable } from "@vibeorm/schema";
+import { VibeError as VibeError4, implicitJoinTable } from "@vibeorm/schema";
 function validationError(params) {
-  return new VibeError3({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError4({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
@@ -593,7 +637,7 @@ function singleField(params) {
   }
   const field = model.fieldByName.get(names[0]);
   if (field === undefined) {
-    throw new VibeError3({
+    throw new VibeError4({
       code: "VIBE_SCHEMA_INVALID",
       message: `relation "${relation.name}" on ${relation.model} names unknown ${what} field "${String(names[0])}"`,
       meta: { model: relation.model, relation: relation.name }
@@ -662,7 +706,7 @@ function resolveRelationLinkUncached(params) {
   }
   const reverse = findReverseRelation({ relation, target });
   if (reverse === null || reverse.fields === undefined || reverse.fields.length === 0) {
-    throw new VibeError3({
+    throw new VibeError4({
       code: "VIBE_SCHEMA_INVALID",
       message: `relation "${relation.name}" on ${relation.model} has no foreign-key counterpart on ${relation.targetModel}`,
       meta: { model: relation.model, relation: relation.name, target: relation.targetModel }
@@ -959,15 +1003,15 @@ var ATOMIC_OPERATIONS = {
   divide: "divide"
 };
 var ALLOWED_ARGS = {
-  findMany: ["where", "orderBy", "take", "skip", "cursor", "distinct", "select", "include", "omit", "relationStrategy"],
-  findFirst: ["where", "orderBy", "take", "skip", "cursor", "distinct", "select", "include", "omit", "relationStrategy"],
-  findUnique: ["where", "select", "include", "omit", "relationStrategy"],
-  create: ["data", "select", "include", "omit"],
+  findMany: ["where", "orderBy", "take", "skip", "cursor", "distinct", "select", "include", "omit", "relationStrategy", "lock"],
+  findFirst: ["where", "orderBy", "take", "skip", "cursor", "distinct", "select", "include", "omit", "relationStrategy", "lock"],
+  findUnique: ["where", "select", "include", "omit", "relationStrategy", "lock"],
+  create: ["data", "select", "include", "omit", "onConflict"],
   createMany: ["data", "skipDuplicates"],
   createManyAndReturn: ["data", "skipDuplicates", "select", "include", "omit"],
-  update: ["where", "data", "select", "include", "omit"],
-  updateMany: ["where", "data"],
-  upsert: ["where", "create", "update", "select", "include", "omit"],
+  update: ["where", "data", "select", "include", "omit", "skipUpdatedAt"],
+  updateMany: ["where", "data", "skipUpdatedAt"],
+  upsert: ["where", "create", "update", "select", "include", "omit", "onConflict"],
   delete: ["where", "select", "include", "omit"],
   deleteMany: ["where"],
   count: ["where", "select", "take", "skip", "orderBy"],
@@ -983,7 +1027,7 @@ var AGG_FN_BY_KEY = {
   _max: "max"
 };
 function validationError2(params) {
-  return new VibeError4({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError5({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
@@ -1003,6 +1047,121 @@ function columnRef(params) {
   const { field, table } = params;
   return table === undefined ? { name: field.columnName } : { table, name: field.columnName };
 }
+function compileLock(params) {
+  const { args, model, method, hasRelations } = params;
+  if (args.lock === undefined)
+    return false;
+  if (model.isView) {
+    throw validationError2({
+      message: `lock on ${model.clientName}.${method}() \u2014 a view row cannot be locked; lock the underlying table's rows instead`,
+      meta: { model: model.name, method }
+    });
+  }
+  if (args.lock !== "update") {
+    throw validationError2({
+      message: `lock on ${model.clientName}.${method}() must be "update", got ${String(args.lock)}`,
+      meta: { model: model.name, method, lock: args.lock }
+    });
+  }
+  if (args.distinct !== undefined) {
+    throw validationError2({
+      message: `lock cannot combine with distinct on ${model.clientName}.${method}() \u2014 postgres rejects FOR UPDATE with DISTINCT`,
+      meta: { model: model.name, method }
+    });
+  }
+  if (hasRelations) {
+    throw validationError2({
+      message: `lock cannot combine with relation loading on ${model.clientName}.${method}() \u2014 lock the parent row alone, then read relations inside the same transaction`,
+      meta: { model: model.name, method }
+    });
+  }
+  return true;
+}
+function compileConflictTarget(params) {
+  const { dialect, meta, model, method, target, where } = params;
+  if ((target !== undefined || where !== undefined) && dialect.doNothingForm === "insertIgnore") {
+    throw unsupportedCapability({
+      dialect: dialect.name,
+      feature: `a conflict target on ${model.clientName}.${method}()`,
+      hint: "mysql's INSERT IGNORE / ON DUPLICATE KEY fire on ANY duplicate key \u2014 no target can be named; gate the call per dialect"
+    });
+  }
+  const out = {};
+  if (target !== undefined) {
+    if (Array.isArray(target)) {
+      if (target.length === 0) {
+        throw validationError2({
+          message: `onConflict target on ${model.clientName}.${method}() must name at least one field`,
+          meta: { model: model.name, method }
+        });
+      }
+      out.columns = target.map((name) => getFieldMeta({ model, field: String(name), context: "onConflict target" }).columnName);
+    } else if (isPlainObject2(target) && typeof target.constraint === "string" && target.constraint.length > 0 && Object.keys(target).length === 1) {
+      if (!dialect.capabilities.conflictTargetConstraint) {
+        throw unsupportedCapability({
+          dialect: dialect.name,
+          feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
+          hint: "only postgres supports ON CONSTRAINT targets \u2014 name the indexed columns instead"
+        });
+      }
+      out.constraint = target.constraint;
+    } else {
+      throw validationError2({
+        message: `onConflict target on ${model.clientName}.${method}() must be a field-name array or { constraint: string }`,
+        meta: { model: model.name, method }
+      });
+    }
+  }
+  if (where !== undefined) {
+    if (out.columns === undefined) {
+      throw validationError2({
+        message: `onConflict where on ${model.clientName}.${method}() needs a column-list target \u2014 the predicate refines "(columns) WHERE \u2026"`,
+        meta: { model: model.name, method }
+      });
+    }
+    if (!dialect.capabilities.partialIndexes) {
+      throw unsupportedCapability({
+        dialect: dialect.name,
+        feature: "a partial-index conflict target",
+        hint: "this dialect has no partial indexes to target"
+      });
+    }
+    if (typeof where !== "string" || where.trim().length === 0) {
+      throw validationError2({
+        message: `onConflict where on ${model.clientName}.${method}() must be the partial index's raw predicate string (the schema declaration's where: text)`,
+        meta: { model: model.name, method }
+      });
+    }
+    out.conflictWhere = where;
+  }
+  return out;
+}
+function compileDbNowWrite(params) {
+  const { model, field, value } = params;
+  if (field.scalarType !== "DateTime" || field.isList) {
+    throw validationError2({
+      message: `dbNow() writes the database clock into a DateTime field \u2014 ${model.name}.${field.name} is ${String(field.enumName ?? field.scalarType)}${field.isList ? "[]" : ""}`,
+      meta: { model: model.name, field: field.name }
+    });
+  }
+  if (field.isId || field.isUnique || model.primaryKey.some((candidate) => candidate.name === field.name)) {
+    throw validationError2({
+      message: `dbNow() on ${model.name}.${field.name} \u2014 a key field cannot take a database-computed value; the client could not re-address the written row`,
+      meta: { model: model.name, field: field.name }
+    });
+  }
+  return dbNowMarker({ offsetSeconds: value.offsetSeconds });
+}
+function compileDbNowFilter(params) {
+  const { model, field, value } = params;
+  if (field.scalarType !== "DateTime" || field.isList) {
+    throw validationError2({
+      message: `dbNow() compares against a DateTime field \u2014 ${model.name}.${field.name} is ${String(field.enumName ?? field.scalarType)}${field.isList ? "[]" : ""}`,
+      meta: { model: model.name, field: field.name }
+    });
+  }
+  return dbNowMarker({ offsetSeconds: value.offsetSeconds });
+}
 function requireObject(params) {
   const { value, what, model } = params;
   if (!isPlainObject2(value)) {
@@ -1319,7 +1478,7 @@ function compileOperatorFilter(params) {
           kind: "cmp",
           op: "eq",
           column,
-          value: encodeFilterValue({ dialect: dialect.name, field, value: operand })
+          value: isDbNow(operand) ? compileDbNowFilter({ model, field, value: operand }) : encodeFilterValue({ dialect: dialect.name, field, value: operand })
         });
         break;
       }
@@ -1343,7 +1502,7 @@ function compileOperatorFilter(params) {
           kind: "cmp",
           op: "ne",
           column,
-          value: encodeFilterValue({ dialect: dialect.name, field, value: operand })
+          value: isDbNow(operand) ? compileDbNowFilter({ model, field, value: operand }) : encodeFilterValue({ dialect: dialect.name, field, value: operand })
         });
         break;
       }
@@ -1355,6 +1514,14 @@ function compileOperatorFilter(params) {
             meta: { model: model.name, field: field.name, operator }
           });
         }
+        for (const item of operand) {
+          if (isDbNow(item)) {
+            throw validationError2({
+              message: `dbNow() cannot ride an "${operator}" list on ${model.name}.${field.name} \u2014 compare with lt/lte/gt/gte/equals instead`,
+              meta: { model: model.name, field: field.name, operator }
+            });
+          }
+        }
         conditions.push({
           kind: "inArray",
           column,
@@ -1371,7 +1538,7 @@ function compileOperatorFilter(params) {
           kind: "cmp",
           op: operator,
           column,
-          value: encodeFilterValue({ dialect: dialect.name, field, value: operand })
+          value: isDbNow(operand) ? compileDbNowFilter({ model, field, value: operand }) : encodeFilterValue({ dialect: dialect.name, field, value: operand })
         });
         break;
       }
@@ -1427,6 +1594,9 @@ function compileFieldFilter(params) {
   if (isDirectValue(value)) {
     return { kind: "cmp", op: "eq", column, value: encodeFilterValue({ dialect: dialect.name, field, value }) };
   }
+  if (isDbNow(value)) {
+    return { kind: "cmp", op: "eq", column, value: compileDbNowFilter({ model, field, value }) };
+  }
   if (Array.isArray(value)) {
     if (!field.isList) {
       throw validationError2({
@@ -1945,7 +2115,7 @@ function expandCompoundWhere(params) {
   for (const [key, value] of Object.entries(where)) {
     if (value === undefined)
       continue;
-    const fields = model.compoundUniques.get(key);
+    const fields = model.compoundUniques.get(key)?.fields;
     if (fields === undefined)
       continue;
     const spec = requireObject({ value, what: `${what}.${key}`, model });
@@ -1964,33 +2134,52 @@ function expandCompoundWhere(params) {
   }
   return expanded ?? where;
 }
+function isAddressableMember(params) {
+  return isDirectValue(params.value) || params.nullsNotDistinct && params.value === null;
+}
 function assertUniqueWhere(params) {
   const { model, where, method } = params;
   for (const field of model.uniqueFields) {
     if (isDirectValue(where[field.name]))
       return;
   }
-  for (const fields of model.compoundUniques.values()) {
-    if (fields.every((field) => isDirectValue(where[field.name])))
+  for (const single of model.singleIndexUniques) {
+    const field = single.fields[0];
+    if (isAddressableMember({ value: where[field.name], nullsNotDistinct: single.nullsNotDistinct }))
       return;
   }
-  const candidates = [...model.uniqueFields.map((field) => field.name), ...model.compoundUniques.keys()];
+  for (const group of model.compoundUniques.values()) {
+    if (group.fields.every((field) => isAddressableMember({ value: where[field.name], nullsNotDistinct: group.nullsNotDistinct })))
+      return;
+  }
+  const candidates = [
+    ...model.uniqueFields.map((field) => field.name),
+    ...model.singleIndexUniques.map((single) => single.fields[0].name),
+    ...model.compoundUniques.keys()
+  ];
   throw validationError2({
     message: `${model.clientName}.${method}() needs a unique where \u2014 one of: ${candidates.join(", ")}`,
     meta: { model: model.name, method, candidates }
   });
 }
-function conflictTargetFields(params) {
+function conflictTargetGroup(params) {
   const { model, where } = params;
   for (const field of model.uniqueFields) {
     if (isDirectValue(where[field.name]))
-      return [field];
+      return { fields: [field], nullsNotDistinct: false };
   }
-  for (const fields of model.compoundUniques.values()) {
-    if (fields.every((field) => isDirectValue(where[field.name])))
-      return fields;
+  for (const single of model.singleIndexUniques) {
+    const field = single.fields[0];
+    if (isAddressableMember({ value: where[field.name], nullsNotDistinct: single.nullsNotDistinct })) {
+      return single;
+    }
   }
-  return model.primaryKey;
+  for (const group of model.compoundUniques.values()) {
+    if (group.fields.every((field) => isAddressableMember({ value: where[field.name], nullsNotDistinct: group.nullsNotDistinct }))) {
+      return group;
+    }
+  }
+  return { fields: model.primaryKey, nullsNotDistinct: false };
 }
 function sameDirectValue(a, b) {
   if (a === b)
@@ -2010,15 +2199,21 @@ function upsertUsesNativeStatement(params) {
   });
   assertUniqueWhere({ model, where, method: "upsert" });
   const create = requireObject({ value: args.create, what: "create", model });
-  const targets = conflictTargetFields({ model, where });
-  const targetNames = new Set(targets.map((field) => field.name));
+  const target = conflictTargetGroup({ model, where });
+  const targetNames = new Set(target.fields.map((field) => field.name));
   for (const [key, value] of Object.entries(where)) {
     if (value === undefined)
       continue;
     if (!targetNames.has(key))
       return false;
   }
-  return targets.every((field) => isDirectValue(create[field.name]) && sameDirectValue(create[field.name], where[field.name]));
+  return target.fields.every((field) => {
+    const createValue = create[field.name];
+    const whereValue = where[field.name];
+    if (target.nullsNotDistinct && createValue === null && whereValue === null)
+      return true;
+    return isDirectValue(createValue) && sameDirectValue(createValue, whereValue);
+  });
 }
 var writePlanCache = new WeakMap;
 function getWritePlan(params) {
@@ -2074,6 +2269,17 @@ function compileCreateRow(params) {
     }
     if (entry.listRefused)
       assertListWritable({ dialect, model, field: entry.field });
+    if (isDbNow(value)) {
+      raw.set(entry.field.name, value);
+      values[entry.field.columnName] = compileDbNowWrite({ model, field: entry.field, value });
+      continue;
+    }
+    if (Array.isArray(value) && value.some((item) => isDbNow(item))) {
+      throw validationError2({
+        message: `dbNow() cannot be a list element (${model.name}.${entry.field.name})`,
+        meta: { model: model.name, field: entry.field.name }
+      });
+    }
     raw.set(entry.field.name, value);
     values[entry.field.columnName] = encodeWith(entry, value);
   }
@@ -2145,6 +2351,16 @@ function compileUpdateSet(params) {
     if (entry.listRefused)
       assertListWritable({ dialect, model, field });
     touched.add(field.name);
+    if (isDbNow(value)) {
+      set[field.columnName] = compileDbNowWrite({ model, field, value });
+      continue;
+    }
+    if (Array.isArray(value) && value.some((item) => isDbNow(item))) {
+      throw validationError2({
+        message: `dbNow() cannot be a list element (${model.name}.${field.name})`,
+        meta: { model: model.name, field: field.name }
+      });
+    }
     if (isPlainObject2(value) && field.scalarType !== "Json") {
       const entries = Object.entries(value).filter(([, operand2]) => operand2 !== undefined);
       if (entries.length !== 1) {
@@ -2155,7 +2371,7 @@ function compileUpdateSet(params) {
       }
       const [operator, operand] = entries[0];
       if (operator === "set") {
-        set[field.columnName] = encodeWith(entry, operand);
+        set[field.columnName] = isDbNow(operand) ? compileDbNowWrite({ model, field, value: operand }) : encodeWith(entry, operand);
         continue;
       }
       if (operator === "push" && field.isList) {
@@ -2174,10 +2390,12 @@ function compileUpdateSet(params) {
     }
     set[field.columnName] = encodeWith(entry, value);
   }
-  for (const entry of plan.injected) {
-    if (!entry.field.isUpdatedAt || touched.has(entry.field.name))
-      continue;
-    set[entry.field.columnName] = encodeWith(entry, new Date);
+  if (params.skipUpdatedAt !== true) {
+    for (const entry of plan.injected) {
+      if (!entry.field.isUpdatedAt || touched.has(entry.field.name))
+        continue;
+      set[entry.field.columnName] = encodeWith(entry, new Date);
+    }
   }
   if (Object.keys(set).length === 0) {
     throw validationError2({
@@ -2277,7 +2495,8 @@ function parseCursor(params) {
   }
   if (fields.length === 1) {
     const field = fields[0];
-    if (!field.isId && !field.isUnique) {
+    const isSingleIndexUnique = model.singleIndexUniques.some((single) => single.fields[0].name === field.name);
+    if (!field.isId && !field.isUnique && !isSingleIndexUnique) {
       throw validationError2({
         message: `cursor field ${model.name}.${field.name} must be @id or @unique \u2014 a non-unique cursor cannot identify a position`,
         meta: { model: model.name, field: field.name }
@@ -2286,7 +2505,7 @@ function parseCursor(params) {
   } else {
     const names = new Set(fields.map((field) => field.name));
     const matchesGroup = (group) => group.length === names.size && group.every((field) => names.has(field.name));
-    const matches = matchesGroup(model.primaryKey) || [...model.compoundUniques.values()].some(matchesGroup);
+    const matches = matchesGroup(model.primaryKey) || [...model.compoundUniques.values()].some((group) => matchesGroup(group.fields));
     if (!matches) {
       const candidates = [
         model.primaryKey.map((field) => field.name).join(" + ") || "none",
@@ -3099,6 +3318,7 @@ function buildQuery(params) {
   switch (method) {
     case "findMany":
     case "findFirst": {
+      const locked = compileLock({ args, model, method, hasRelations: relations !== null });
       const shape = buildFindShape({
         dialect,
         meta,
@@ -3111,12 +3331,13 @@ function buildQuery(params) {
       });
       return {
         ...base,
-        statement: shape.statement,
+        statement: locked ? { ...shape.statement, lockForUpdate: true } : shape.statement,
         reverseRows: shape.reverseRows,
         resortBy: shape.resortBy
       };
     }
     case "findUnique": {
+      const locked = compileLock({ args, model, method, hasRelations: relations !== null });
       const where = expandCompoundWhere({
         model,
         where: requireObject({ value: args.where, what: "where", model })
@@ -3131,7 +3352,10 @@ function buildQuery(params) {
         ...useLateral ? { selection: relations } : {},
         clientOptions: undefined
       });
-      return { ...base, statement: shape.statement };
+      return {
+        ...base,
+        statement: locked ? { ...shape.statement, lockForUpdate: true } : shape.statement
+      };
     }
     case "count": {
       const where = args.where === undefined ? undefined : compileWhere({ dialect, meta, model, where: requireObject({ value: args.where, what: "where", model }) });
@@ -3321,6 +3545,38 @@ function buildQuery(params) {
       };
     }
     case "create": {
+      let conflictClause;
+      if (args.onConflict !== undefined) {
+        const spec = requireObject({ value: args.onConflict, what: "onConflict", model });
+        for (const key of Object.keys(spec)) {
+          if (key !== "action" && key !== "target" && key !== "where") {
+            throw validationError2({
+              message: `unknown onConflict key "${key}" on ${model.clientName}.create() \u2014 expected action/target/where`,
+              meta: { model: model.name, key }
+            });
+          }
+        }
+        if (spec.action !== "nothing") {
+          throw validationError2({
+            message: `onConflict.action on ${model.clientName}.create() must be "nothing" (conflicting rows are skipped \u2014 to update instead, use upsert())`,
+            meta: { model: model.name }
+          });
+        }
+        const compiled = compileConflictTarget({
+          dialect,
+          meta,
+          model,
+          method,
+          target: spec.target,
+          where: spec.where
+        });
+        conflictClause = {
+          doNothing: true,
+          ...compiled.columns === undefined ? {} : { columns: compiled.columns },
+          ...compiled.constraint === undefined ? {} : { constraint: compiled.constraint },
+          ...compiled.conflictWhere === undefined ? {} : { conflictWhere: compiled.conflictWhere }
+        };
+      }
       const row = compileCreateRow({ dialect, model, data: args.data });
       const columns = orderedColumns({ model, values: row.values });
       if (columns.length === 0) {
@@ -3337,6 +3593,7 @@ function buildQuery(params) {
           table: { name: model.tableName },
           columns,
           rows: [columns.map((column) => row.values[column])],
+          ...conflictClause === undefined ? {} : { onConflict: conflictClause },
           returning: returningColumns({ model, selectedFields })
         }
       };
@@ -3351,13 +3608,40 @@ function buildQuery(params) {
         });
       }
       const groups = compileCreateRows({ dialect, model, data: args.data });
-      const skipDuplicates = args.skipDuplicates === true;
+      let manyConflict;
+      if (args.skipDuplicates === true) {
+        manyConflict = { doNothing: true };
+      } else if (args.skipDuplicates !== undefined && args.skipDuplicates !== false) {
+        const spec = requireObject({ value: args.skipDuplicates, what: "skipDuplicates", model });
+        for (const key of Object.keys(spec)) {
+          if (key !== "target" && key !== "where") {
+            throw validationError2({
+              message: `unknown skipDuplicates key "${key}" on ${model.clientName}.${method}() \u2014 expected target/where`,
+              meta: { model: model.name, key }
+            });
+          }
+        }
+        const compiled = compileConflictTarget({
+          dialect,
+          meta,
+          model,
+          method,
+          target: spec.target,
+          where: spec.where
+        });
+        manyConflict = {
+          doNothing: true,
+          ...compiled.columns === undefined ? {} : { columns: compiled.columns },
+          ...compiled.constraint === undefined ? {} : { constraint: compiled.constraint },
+          ...compiled.conflictWhere === undefined ? {} : { conflictWhere: compiled.conflictWhere }
+        };
+      }
       const statements = groups.map((group) => ({
         kind: "insert",
         table: { name: model.tableName },
         columns: group.columns,
         rows: group.rows,
-        ...skipDuplicates ? { onConflict: { doNothing: true } } : {},
+        ...manyConflict === undefined ? {} : { onConflict: manyConflict },
         ...method === "createManyAndReturn" ? { returning: returningColumns({ model, selectedFields }) } : {}
       }));
       return {
@@ -3369,6 +3653,12 @@ function buildQuery(params) {
     case "update":
     case "updateMany": {
       const isUnique = method === "update";
+      if (args.skipUpdatedAt !== undefined && typeof args.skipUpdatedAt !== "boolean") {
+        throw validationError2({
+          message: `skipUpdatedAt on ${model.clientName}.${method}() must be a boolean, got ${String(args.skipUpdatedAt)}`,
+          meta: { model: model.name, method }
+        });
+      }
       const raw = requireObject({ value: args.where, what: "where", model });
       const where = isUnique ? expandCompoundWhere({ model, where: raw }) : raw;
       if (isUnique)
@@ -3380,13 +3670,36 @@ function buildQuery(params) {
         statement: {
           kind: "update",
           table: { name: model.tableName },
-          set: compileUpdateSet({ dialect, model, data: args.data }),
+          set: compileUpdateSet({
+            dialect,
+            model,
+            data: args.data,
+            ...args.skipUpdatedAt === true ? { skipUpdatedAt: true } : {}
+          }),
           ...compiled === undefined ? {} : { where: compiled },
           ...isUnique ? { returning: returningColumns({ model, selectedFields }) } : {}
         }
       };
     }
     case "upsert": {
+      let constraintTarget;
+      if (args.onConflict !== undefined) {
+        const spec = requireObject({ value: args.onConflict, what: "onConflict", model });
+        if (typeof spec.constraint !== "string" || spec.constraint.length === 0 || Object.keys(spec).length !== 1) {
+          throw validationError2({
+            message: `onConflict on ${model.clientName}.upsert() must be { constraint: string } \u2014 the named unique constraint that arbitrates the conflict`,
+            meta: { model: model.name }
+          });
+        }
+        if (!dialect.capabilities.conflictTargetConstraint) {
+          throw unsupportedCapability({
+            dialect: dialect.name,
+            feature: "a named-constraint conflict target on upsert",
+            hint: "only postgres supports ON CONFLICT ON CONSTRAINT \u2014 rely on the where-derived column target instead"
+          });
+        }
+        constraintTarget = spec.constraint;
+      }
       const where = expandCompoundWhere({
         model,
         where: requireObject({ value: args.where, what: "where", model })
@@ -3394,10 +3707,10 @@ function buildQuery(params) {
       assertUniqueWhere({ model, where, method });
       const row = compileCreateRow({ dialect, model, data: args.create });
       const columns = orderedColumns({ model, values: row.values });
-      const targetFields = conflictTargetFields({ model, where });
+      const targetFields = conflictTargetGroup({ model, where }).fields;
       for (const field of targetFields) {
         if (!(field.columnName in row.values)) {
-          throw new VibeError4({
+          throw new VibeError5({
             code: "VIBE_INTERNAL",
             message: `upsert on ${model.name}: create data does not bind conflict-target column "${field.columnName}" \u2014 this shape must run the find-then-write fallback flow`,
             meta: { model: model.name, column: field.columnName }
@@ -3408,7 +3721,7 @@ function buildQuery(params) {
       for (const [key, value] of Object.entries(where)) {
         if (value === undefined || nativeTargetNames.has(key))
           continue;
-        throw new VibeError4({
+        throw new VibeError5({
           code: "VIBE_INTERNAL",
           message: `upsert on ${model.name}: where field "${key}" is not part of the conflict target \u2014 guarded upserts must run the find-then-write fallback flow`,
           meta: { model: model.name, field: key }
@@ -3428,6 +3741,7 @@ function buildQuery(params) {
           rows: [columns.map((column) => row.values[column])],
           onConflict: {
             columns: targetFields.map((field) => field.columnName),
+            ...constraintTarget === undefined ? {} : { constraint: constraintTarget },
             update,
             ...odkuKeyColumn === undefined ? {} : { lastInsertIdColumn: odkuKeyColumn }
           },
@@ -3457,10 +3771,10 @@ function buildQuery(params) {
   }
 }
 // packages/runtime/src/relation-loader.ts
-import { VibeError as VibeError6 } from "@vibeorm/schema";
+import { VibeError as VibeError7 } from "@vibeorm/schema";
 
 // packages/runtime/src/computed.ts
-import { VibeError as VibeError5 } from "@vibeorm/schema";
+import { VibeError as VibeError6 } from "@vibeorm/schema";
 function sameNeeds(a, b) {
   if (a.length !== b.length)
     return false;
@@ -3496,7 +3810,7 @@ function assertComputedManifest(params) {
     problems.push(`"${key}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError5({
+    throw new VibeError6({
       code: "VIBE_STALE_CLIENT",
       message: `computed-field config changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { problems }
@@ -3660,7 +3974,7 @@ async function loadManyToMany(params) {
   const link = node.link;
   const join = link.join;
   if (join === null) {
-    throw new VibeError6({
+    throw new VibeError7({
       code: "VIBE_INTERNAL",
       message: `manyToMany relation "${node.name}" resolved without join-table wiring`
     });
@@ -3858,7 +4172,7 @@ async function attachLateralRelations(params) {
         try {
           parsed = JSON.parse(raw);
         } catch (cause) {
-          throw new VibeError6({
+          throw new VibeError7({
             code: "VIBE_INTERNAL",
             message: `relation column "${column}" returned text that is not valid JSON`,
             meta: { relation: node.name },
@@ -3895,12 +4209,12 @@ async function attachLateralRelations(params) {
   await loadCounts({ ctx, model, rows, counts: selection.counts });
 }
 // packages/runtime/src/nested-writes.ts
-import { VibeError as VibeError7 } from "@vibeorm/schema";
+import { VibeError as VibeError8 } from "@vibeorm/schema";
 function validationError3(params) {
-  return new VibeError7({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError8({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function notFound(params) {
-  return new VibeError7({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
+  return new VibeError8({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
 }
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
@@ -4730,7 +5044,7 @@ async function updateWithNested(params) {
   });
 }
 // packages/runtime/src/extensions.ts
-import { VibeError as VibeError8, extensionManifestEntry } from "@vibeorm/schema";
+import { VibeError as VibeError9, extensionManifestEntry } from "@vibeorm/schema";
 function assertExtensionManifest(params) {
   const { manifest } = params;
   const instances = params.instances ?? [];
@@ -4753,7 +5067,7 @@ function assertExtensionManifest(params) {
     problems.push(`"${name}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError8({
+    throw new VibeError9({
       code: "VIBE_STALE_CLIENT",
       message: `extension list changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { manifest, problems }
@@ -4768,7 +5082,7 @@ function buildExtensionOperatorMap(params) {
     for (const operator of extension.sql?.whereOperators ?? []) {
       const existing = owner.get(operator.name);
       if (existing !== undefined) {
-        throw new VibeError8({
+        throw new VibeError9({
           code: "VIBE_CONFIG",
           message: `where operator "${operator.name}" is claimed by both "${existing}" and "${extension.name}"`,
           meta: { operator: operator.name }
@@ -4784,7 +5098,7 @@ function buildExtensionOperatorMap(params) {
           options: extension.options
         });
         if ("error" in compiled) {
-          throw new VibeError8({
+          throw new VibeError9({
             code: "VIBE_VALIDATION",
             message: `"${operator.name}" on ${model}.${field}: ${compiled.error}`,
             meta: { model, field, operator: operator.name, extension: extension.name }
@@ -4816,9 +5130,9 @@ function buildConnectHooks(params) {
   return hooks;
 }
 // packages/runtime/src/views.ts
-import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { VibeError as VibeError10 } from "@vibeorm/schema";
 function validationError4(params) {
-  return new VibeError9({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError10({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 
 class ViewResult {
@@ -5170,7 +5484,7 @@ function createView(params) {
   for (const [clientName, mask] of resolved) {
     const delegate = models[clientName];
     if (delegate === undefined) {
-      throw new VibeError9({
+      throw new VibeError10({
         code: "VIBE_INTERNAL",
         message: `view "${name}": no delegate for model "${mask.model.name}"`,
         meta: { view: name, model: mask.model.name }
@@ -5186,11 +5500,11 @@ function attachDefineView(params) {
   Object.defineProperty(client, "$defineView", { value, enumerable: true });
 }
 // packages/runtime/src/client.ts
-import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError11, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 import { ParamCollector, getSqlDialect } from "@vibeorm/sql";
 
 // packages/runtime/src/render-cache.ts
-import { isListSetOperation, isSetOperation, isSqlDefaultCell, renderStatement, strictMatchPattern } from "@vibeorm/sql";
+import { isDbNowMarker, isListSetOperation, isSetOperation, isSqlDefaultCell, renderStatement, strictMatchPattern } from "@vibeorm/sql";
 var MAX_ENTRIES = 512;
 
 class StatementRenderCache {
@@ -5240,6 +5554,13 @@ function addSetEntry(walk, name, value) {
     walk.values.push(value.value);
     return;
   }
+  if (isDbNowMarker(value)) {
+    walk.key += value.offsetSeconds === 0 ? "=N0" : "=N1";
+    addIdent(walk, name);
+    if (value.offsetSeconds !== 0)
+      walk.values.push(value.offsetSeconds);
+    return;
+  }
   if (isListSetOperation(value)) {
     walk.key += `=l${value.__listOp}`;
     addIdent(walk, name);
@@ -5263,6 +5584,13 @@ function addReturning(walk, returning) {
 function walkExpr(walk, dialect, expr) {
   switch (expr.kind) {
     case "cmp":
+      if (isDbNowMarker(expr.value)) {
+        walk.key += `cN${expr.op}${expr.value.offsetSeconds === 0 ? "0" : "1"}`;
+        addCol(walk, expr.column);
+        if (expr.value.offsetSeconds !== 0)
+          walk.values.push(expr.value.offsetSeconds);
+        return true;
+      }
       walk.key += `c${expr.op}`;
       addCol(walk, expr.column);
       walk.values.push(expr.value);
@@ -5478,7 +5806,7 @@ function walkSelect(walk, dialect, statement) {
   walk.key += "}";
   return true;
 }
-function walkInsert(walk, statement) {
+function walkInsert(walk, dialect, statement) {
   walk.key += "I{";
   addTable(walk, statement.table);
   walk.key += "c(";
@@ -5494,7 +5822,11 @@ function walkInsert(walk, statement) {
       const value = row[cell];
       if (isSqlDefaultCell(value))
         walk.key += `D${rowIndex}:${cell};`;
-      else
+      else if (isDbNowMarker(value)) {
+        walk.key += `T${rowIndex}:${cell}:${value.offsetSeconds === 0 ? "0" : "1"};`;
+        if (value.offsetSeconds !== 0)
+          walk.values.push(value.offsetSeconds);
+      } else
         walk.values.push(value);
     }
   }
@@ -5502,13 +5834,25 @@ function walkInsert(walk, statement) {
   if (onConflict !== undefined) {
     if ("doNothing" in onConflict) {
       walk.key += "N(";
+      if (onConflict.constraint !== undefined) {
+        walk.key += "K";
+        addIdent(walk, onConflict.constraint);
+      }
       if (onConflict.columns !== undefined) {
         for (const name of onConflict.columns)
           addIdent(walk, name);
       }
+      if (onConflict.conflictWhere !== undefined) {
+        walk.key += "w";
+        addIdent(walk, onConflict.conflictWhere);
+      }
       walk.key += ")";
     } else {
       walk.key += "U(";
+      if (onConflict.constraint !== undefined) {
+        walk.key += "K";
+        addIdent(walk, onConflict.constraint);
+      }
       for (const name of onConflict.columns)
         addIdent(walk, name);
       walk.key += ":";
@@ -5556,7 +5900,7 @@ function walkStatement(walk, dialect, statement) {
     case "select":
       return walkSelect(walk, dialect, statement);
     case "insert":
-      return walkInsert(walk, statement);
+      return walkInsert(walk, dialect, statement);
     case "update":
       return walkUpdate(walk, dialect, statement);
     case "delete":
@@ -5606,7 +5950,7 @@ function renderStatementCached(params) {
 // packages/runtime/src/client.ts
 function notFound2(params) {
   const { model, method } = params;
-  return new VibeError10({
+  return new VibeError11({
     code: "VIBE_NOT_FOUND",
     message: `no ${model} record matched the where clause of ${method}()`,
     meta: { model, method }
@@ -5614,7 +5958,7 @@ function notFound2(params) {
 }
 function viewIsReadOnly(params) {
   const { model, method } = params;
-  return new VibeError10({
+  return new VibeError11({
     code: "VIBE_VALIDATION",
     message: `${model} is a view \u2014 ${method}() is not available on views (they are read-only); write to the underlying table instead`,
     meta: { model, method }
@@ -5743,7 +6087,7 @@ class QueryPromise extends Promise {
   }
   claim() {
     if (this.started) {
-      throw new VibeError10({
+      throw new VibeError11({
         code: "VIBE_VALIDATION",
         message: "$transaction([...]) needs operations that have not dispatched \u2014 pass delegate calls in the same tick they are created (this one was awaited or created earlier and already executed outside the transaction)"
       });
@@ -5790,7 +6134,7 @@ async function runAffected(params) {
   if (plan.batch !== undefined && plan.batch.length > 1) {
     const batch = plan.batch;
     return await engine.adapter.transaction(async (txAdapter) => {
-      const txEngine = { ...engine, adapter: txAdapter };
+      const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
       let total = 0;
       for (const statement of batch) {
         total += await runAffected({ engine: txEngine, plan: { ...plan, statement, batch: undefined } });
@@ -5820,6 +6164,13 @@ async function runAffected(params) {
 }
 function plan(params) {
   const { engine, model, method, args } = params;
+  if (args !== undefined && args["lock"] !== undefined && engine.inTransaction !== true) {
+    throw new VibeError11({
+      code: "VIBE_VALIDATION",
+      message: `lock on ${model}.${method}() requires a transaction \u2014 call it on the client $transaction hands its callback (outside one, the lock would release at statement end)`,
+      meta: { model, method }
+    });
+  }
   return buildQuery({
     meta: engine.meta,
     dialect: engine.dialect,
@@ -5887,7 +6238,7 @@ async function insertedKeyWhere(params) {
   });
   const id = result.rows[0]?.id;
   if (id === undefined || id === null) {
-    throw new VibeError10({
+    throw new VibeError11({
       code: "VIBE_INTERNAL",
       message: `could not read back the generated key for ${source.model.name}`,
       meta: { model: source.model.name }
@@ -5902,8 +6253,11 @@ async function runSingleMutation(params) {
   if (requested !== undefined && requested.length > 0 && engine.dialect.capabilities.returning) {
     const rows = await runRows({ engine, plan: source });
     const row = rows[0];
-    if (row === undefined)
+    if (row === undefined) {
+      if (params.allowZeroRows === true)
+        return null;
       throw notFound2({ model: source.model.name, method: source.method });
+    }
     return row;
   }
   const rendered = renderStatementCached({ dialect: engine.dialect, statement, cache: engine.renderCache });
@@ -5928,7 +6282,7 @@ async function runSingleMutation(params) {
     if (where === null)
       throw notFound2({ model: source.model.name, method: source.method });
     return await engine.adapter.transaction(async (txAdapter) => {
-      const txEngine = { ...engine, adapter: txAdapter };
+      const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
       const before = await refetch({ engine: txEngine, source, where, lock: true });
       if (before === null)
         throw notFound2({ model: source.model.name, method: source.method });
@@ -5942,7 +6296,7 @@ async function runSingleMutation(params) {
     const knownWhere = source.refetchWhere;
     if (source.method === "upsert") {
       return await engine.adapter.transaction(async (txAdapter) => {
-        const txEngine = { ...engine, adapter: txAdapter };
+        const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
         await executeWrite(txEngine);
         const byWhere = await refetch({ engine: txEngine, source, where: knownWhere });
         if (byWhere !== null)
@@ -5966,9 +6320,9 @@ async function runSingleMutation(params) {
     }
     if (source.method === "update") {
       return await engine.adapter.transaction(async (txAdapter) => {
-        const txEngine = { ...engine, adapter: txAdapter };
-        const affected = await executeWrite(txEngine);
-        if (affected === 0)
+        const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
+        const affected2 = await executeWrite(txEngine);
+        if (affected2 === 0)
           throw notFound2({ model: source.model.name, method: source.method });
         const after2 = await refetch({ engine: txEngine, source, where: knownWhere });
         if (after2 === null)
@@ -5976,15 +6330,19 @@ async function runSingleMutation(params) {
         return after2;
       });
     }
-    await executeWrite(engine);
+    const affected = await executeWrite(engine);
+    if (affected === 0 && params.allowZeroRows === true)
+      return null;
     const after = await refetch({ engine, source, where: knownWhere });
     if (after === null)
       throw notFound2({ model: source.model.name, method: source.method });
     return after;
   }
   return await engine.adapter.transaction(async (txAdapter) => {
-    const txEngine = { ...engine, adapter: txAdapter };
-    await executeWrite(txEngine);
+    const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
+    const affected = await executeWrite(txEngine);
+    if (affected === 0 && params.allowZeroRows === true)
+      return null;
     const where = await insertedKeyWhere({ engine: txEngine, source });
     const after = await refetch({ engine: txEngine, source, where });
     if (after === null)
@@ -5992,6 +6350,11 @@ async function runSingleMutation(params) {
     return after;
   });
 }
+function requireRow(params) {
+  if (params.row === null)
+    throw notFound2({ model: params.model, method: params.method });
+  return params.row;
+}
 async function runUpsertFallback(params) {
   const { engine, model, args } = params;
   const passthrough = {};
@@ -6019,10 +6382,14 @@ async function runUpsertFallback(params) {
     args: { ...passthrough, where: args.where, data: args.update }
   });
   return await engine.adapter.transaction(async (txAdapter) => {
-    const txEngine = { ...engine, adapter: txAdapter };
+    const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
     const existing = (await runRows({ engine: txEngine, plan: probePlan }))[0];
     const source = existing === undefined ? createSource : updateSource;
-    return await runSingleMutation({ engine: txEngine, source, readBeforeWrite: false });
+    return requireRow({
+      row: await runSingleMutation({ engine: txEngine, source, readBeforeWrite: false }),
+      model: model.name,
+      method: "upsert"
+    });
   });
 }
 function relationExecutor(params) {
@@ -6079,10 +6446,14 @@ async function finalizeRow(params) {
 function makeRunner(params) {
   const { engine } = params;
   return {
-    single: async ({ model, method, args }) => await runSingleMutation({
-      engine,
-      source: plan({ engine, model, method, args }),
-      readBeforeWrite: method === "delete"
+    single: async ({ model, method, args }) => requireRow({
+      row: await runSingleMutation({
+        engine,
+        source: plan({ engine, model, method, args }),
+        readBeforeWrite: method === "delete"
+      }),
+      model,
+      method
     }),
     rows: async ({ model, method, args }) => await runRows({ engine, plan: plan({ engine, model, method, args }) }),
     affected: async ({ model, method, args }) => await runAffected({ engine, plan: plan({ engine, model, method, args }) }),
@@ -6108,7 +6479,7 @@ function makeWriteContext(params) {
     meta: engine.meta,
     dialect: engine.dialect,
     run: makeRunner({ engine }),
-    transactional: (fn) => engine.adapter.transaction((txAdapter) => fn(makeRunner({ engine: { ...engine, adapter: txAdapter } })))
+    transactional: (fn) => engine.adapter.transaction((txAdapter) => fn(makeRunner({ engine: { ...engine, adapter: txAdapter, inTransaction: true } })))
   };
 }
 function readOnlyDelegate(params) {
@@ -6166,7 +6537,15 @@ function createDelegate(params) {
   };
   const create = async (target, args) => {
     const modelMeta = getModelMeta({ meta: target.meta, model });
+    const skipping = args.onConflict !== undefined;
     if (hasNestedWrites({ model: modelMeta, data: args.data })) {
+      if (skipping) {
+        throw new VibeError11({
+          code: "VIBE_VALIDATION",
+          message: `onConflict cannot combine with nested writes on ${modelMeta.name}.create() \u2014 insert the parent row alone, then connect relations`,
+          meta: { model: modelMeta.name }
+        });
+      }
       const shape = resolveResultShape({ meta: target.meta, model: modelMeta, method: "create", args });
       const row2 = await createWithNested({
         ctx: makeWriteContext({ engine: target }),
@@ -6181,7 +6560,14 @@ function createDelegate(params) {
       });
     }
     const built = plan({ engine: target, model, method: "create", args });
-    const row = await runSingleMutation({ engine: target, source: built, readBeforeWrite: false });
+    const row = await runSingleMutation({
+      engine: target,
+      source: built,
+      readBeforeWrite: false,
+      ...skipping ? { allowZeroRows: true } : {}
+    });
+    if (row === null)
+      return null;
     return await finalizeRow({ engine: target, model: built.model, shape: shapeOf(built), row });
   };
   const update = async (target, args) => {
@@ -6202,7 +6588,11 @@ function createDelegate(params) {
       });
     }
     const built = plan({ engine: target, model, method: "update", args });
-    const row = await runSingleMutation({ engine: target, source: built, readBeforeWrite: false });
+    const row = requireRow({
+      row: await runSingleMutation({ engine: target, source: built, readBeforeWrite: false }),
+      model: built.model.name,
+      method: "update"
+    });
     return await finalizeRow({ engine: target, model: built.model, shape: shapeOf(built), row });
   };
   const createMany = async (target, args) => {
@@ -6234,13 +6624,20 @@ function createDelegate(params) {
   const upsert = async (target, args) => {
     const modelMeta = getModelMeta({ meta: target.meta, model });
     if (hasNestedWrites({ model: modelMeta, data: args.create }) || hasNestedWrites({ model: modelMeta, data: args.update })) {
-      throw new VibeError10({
+      throw new VibeError11({
         code: "VIBE_VALIDATION",
         message: `nested writes are not supported inside upsert arms on ${modelMeta.name} \u2014 use create()/update() with nested data`,
         meta: { model: modelMeta.name }
       });
     }
     if (!upsertUsesNativeStatement({ model: modelMeta, args })) {
+      if (args.onConflict !== undefined) {
+        throw new VibeError11({
+          code: "VIBE_VALIDATION",
+          message: `onConflict on ${modelMeta.name}.upsert() needs the native single-statement path \u2014 this shape (a guard field beyond the conflict target, or create data not binding the where's key) runs the find-then-write fallback, which cannot honor an explicit conflict target`,
+          meta: { model: modelMeta.name }
+        });
+      }
       const shape = resolveResultShape({
         meta: target.meta,
         model: modelMeta,
@@ -6256,12 +6653,20 @@ function createDelegate(params) {
       });
     }
     const built = plan({ engine: target, model, method: "upsert", args });
-    const row = await runSingleMutation({ engine: target, source: built, readBeforeWrite: false });
+    const row = requireRow({
+      row: await runSingleMutation({ engine: target, source: built, readBeforeWrite: false }),
+      model: built.model.name,
+      method: "upsert"
+    });
     return await finalizeRow({ engine: target, model: built.model, shape: shapeOf(built), row });
   };
   const deleteOne = async (target, args) => {
     const built = plan({ engine: target, model, method: "delete", args });
-    const row = await runSingleMutation({ engine: target, source: built, readBeforeWrite: true });
+    const row = requireRow({
+      row: await runSingleMutation({ engine: target, source: built, readBeforeWrite: true }),
+      model: built.model.name,
+      method: "delete"
+    });
     return await finalizeRow({ engine: target, model: built.model, shape: shapeOf(built), row });
   };
   const deleteMany = async (target, args) => {
@@ -6389,7 +6794,7 @@ function buildClient(params) {
     let claimError = null;
     for (const operation of operations) {
       if (!(operation instanceof QueryPromise)) {
-        claimError = new VibeError10({
+        claimError = new VibeError11({
           code: "VIBE_VALIDATION",
           message: "$transaction([...]) takes query promises from model delegate calls \u2014 a foreign promise is already running and cannot join the transaction"
         });
@@ -6408,7 +6813,7 @@ function buildClient(params) {
       return Promise.reject(claimError);
     }
     return engine.adapter.transaction(async (txAdapter) => {
-      const txEngine = { ...engine, adapter: txAdapter };
+      const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
       const results = [];
       let index = 0;
       try {
@@ -6428,7 +6833,7 @@ function buildClient(params) {
     $models: models,
     $on: (event, listener) => {
       if (event !== "query") {
-        throw new VibeError10({
+        throw new VibeError11({
           code: "VIBE_VALIDATION",
           message: `unknown client event "${String(event)}" \u2014 supported: "query"`,
           meta: { event }
@@ -6439,7 +6844,7 @@ function buildClient(params) {
         engine.listeners.delete(listener);
       };
     },
-    $transaction: (fnOrOperations, options) => Array.isArray(fnOrOperations) ? runOperations(fnOrOperations, options) : engine.adapter.transaction((txAdapter) => fnOrOperations(buildClient({ engine: { ...engine, adapter: txAdapter } })), options),
+    $transaction: (fnOrOperations, options) => Array.isArray(fnOrOperations) ? runOperations(fnOrOperations, options) : engine.adapter.transaction((txAdapter) => fnOrOperations(buildClient({ engine: { ...engine, adapter: txAdapter, inTransaction: true } })), options),
     $queryRaw: async (strings, ...values) => (await runRaw("$queryRaw", buildRawStatement({ dialect: engine.dialect, strings, values }))).rows,
     $executeRaw: async (strings, ...values) => (await runRaw("$executeRaw", buildRawStatement({ dialect: engine.dialect, strings, values }))).affectedRows,
     $queryRawUnsafe: async (text, ...values) => (await runRaw("$queryRawUnsafe", { text, values })).rows,
@@ -6491,7 +6896,7 @@ function makeMountContext(params) {
     compileWhere: ({ where, model: modelName, qualify }) => {
       const target = modelName === undefined ? model : getModelMeta({ meta: engine.meta, model: modelName });
       if (target === null) {
-        throw new VibeError10({
+        throw new VibeError11({
           code: "VIBE_INTERNAL",
           message: `extension "${extension}" compiled a where with no model in scope`,
           meta: { extension }
@@ -6517,7 +6922,7 @@ function attachExtensionMounts(params) {
       const model = getModelMeta({ meta: engine.meta, model: mount.model ?? "" });
       const delegate = models[model.name];
       if (delegate === undefined || mount.property in delegate) {
-        throw new VibeError10({
+        throw new VibeError11({
           code: "VIBE_CONFIG",
           message: `extension "${mount.extension}" cannot mount "${mount.property}" on ${model.name} \u2014 the name is taken`,
           meta: { extension: mount.extension, model: model.name, property: mount.property }
@@ -6528,7 +6933,7 @@ function attachExtensionMounts(params) {
       continue;
     }
     if (!mount.property.startsWith("$") || mount.property in client) {
-      throw new VibeError10({
+      throw new VibeError11({
         code: "VIBE_CONFIG",
         message: `extension "${mount.extension}" cannot mount client property "${mount.property}" \u2014 root mounts are $-prefixed and must not collide`,
         meta: { extension: mount.extension, property: mount.property }
@@ -6548,7 +6953,7 @@ function createClient(params) {
     assertComputedManifest({ manifest: computed.manifest, specs: computed.specs });
   }
   if (computed === undefined && options !== undefined && options["computed"] !== undefined) {
-    throw new VibeError10({
+    throw new VibeError11({
       code: "VIBE_CONFIG",
       message: "this client was generated without computed fields \u2014 declare them in vibeorm.config.ts and re-run vibeorm generate",
       meta: {}
@@ -6583,6 +6988,7 @@ export {
   resolveRelationSelection,
   resolveRelationLink,
   lateralColumnAlias,
+  isDbNow,
   hasNestedWrites,
   getModelMeta,
   getFieldMeta,
@@ -6598,6 +7004,7 @@ export {
   decodeRow,
   decodeIsNoop2 as decodeIsNoop,
   decodeAggregateValue,
+  dbNow,
   createWithNested,
   createView,
   createClient,
@@ -6622,4 +7029,4 @@ export {
   COUNT_ALIAS
 };
 
-//# debugId=D09B25CE72AA9DC064756E2164756E21
+//# debugId=0C003BB2F334C66D64756E2164756E21