@vibeorm/runtime 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/db-now.d.ts

@@ -18,7 +18,7 @@
 /** The database-clock sentinel produced by {@link dbNow}. */
 export type DbNow = {
     readonly __vibeDbNow: true;
-    /** Whole seconds added to the database's now() (negative = past). */
+    /** Seconds added to the database's now() (fractional OK; negative = past). */
     readonly offsetSeconds: number;
 };
 /**

package/dist/db-now.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db-now.d.ts","sourceRoot":"","sources":["../src/db-now.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,6DAA6D;AAC7D,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,CAUxE;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAYtD"}
+{"version":3,"file":"db-now.d.ts","sourceRoot":"","sources":["../src/db-now.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,6DAA6D;AAC7D,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,CAUxE;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAYtD"}

package/dist/index.js

@@ -14,10 +14,10 @@ function toSqlExecutor(params) {
 import { VibeError } from "@vibeorm/schema";
 function dbNow(options) {
   const offset = options?.plusSeconds ?? 0;
-  if (typeof offset !== "number" || !Number.isInteger(offset)) {
+  if (typeof offset !== "number" || !Number.isFinite(offset)) {
     throw new VibeError({
       code: "VIBE_VALIDATION",
-      message: `dbNow plusSeconds must be a whole number of seconds, got ${String(offset)}`,
+      message: `dbNow plusSeconds must be a finite number of seconds (fractional is fine), got ${String(offset)}`,
       meta: { plusSeconds: offset }
     });
   }
@@ -31,7 +31,7 @@ function isDbNow(value) {
     return false;
   }
   const candidate = value;
-  return candidate.__vibeDbNow === true && typeof candidate.offsetSeconds === "number" && Number.isInteger(candidate.offsetSeconds);
+  return candidate.__vibeDbNow === true && typeof candidate.offsetSeconds === "number" && Number.isFinite(candidate.offsetSeconds);
 }
 // packages/runtime/src/model-meta.ts
 import { VibeError as VibeError2, isEnumType, validateComputedConfig } from "@vibeorm/schema";
@@ -167,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;
   };
-  if (primaryKey.length > 1)
-    addCompound(primaryKey.map((field) => field.name));
+  const addCompound = (names, nullsNotDistinct, clientName) => {
+    if (names.length < 2)
+      return;
+    const key = clientName ?? 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), false, model.primaryKey?.clientName);
+  }
   for (const index of model.indexes) {
-    if (index.kind === "unique" && index.where === undefined) {
-      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, index.clientName);
     }
   }
   const computedSpecs = params.computed;
@@ -204,6 +223,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,
@@ -2096,7 +2116,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 });
@@ -2115,33 +2135,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;
+  }
+  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.compoundUniques.keys()];
+  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 single of model.singleIndexUniques) {
+    const field = single.fields[0];
+    if (isAddressableMember({ value: where[field.name], nullsNotDistinct: single.nullsNotDistinct })) {
+      return single;
+    }
   }
-  for (const fields of model.compoundUniques.values()) {
-    if (fields.every((field) => isDirectValue(where[field.name])))
-      return fields;
+  for (const group of model.compoundUniques.values()) {
+    if (group.fields.every((field) => isAddressableMember({ value: where[field.name], nullsNotDistinct: group.nullsNotDistinct }))) {
+      return group;
+    }
   }
-  return model.primaryKey;
+  return { fields: model.primaryKey, nullsNotDistinct: false };
 }
 function sameDirectValue(a, b) {
   if (a === b)
@@ -2161,15 +2200,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) {
@@ -2451,7 +2496,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 }
@@ -2460,7 +2506,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",
@@ -3662,7 +3708,7 @@ 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 VibeError5({
@@ -6984,4 +7030,4 @@ export {
   COUNT_ALIAS
 };
 
-//# debugId=DDDCD7D2210268EA64756E2164756E21
+//# debugId=4B6B11C516D4A81A64756E2164756E21