@vibeorm/dsl 2.3.0 → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VibeORM contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -69,7 +69,7 @@ Id strategies are `dsl.id({ type: "ulid" | "uuid" | "cuid" | "nanoid" | "autoinc
 
 On every column: `.optional()`, `.unique()`, `.index()`, `.array()`, `.default(value)`, `.map("db_col")`, `.dbgenerated("expr")`, `.comment("...")`.
 
-Kind-specific: `.maxLength(n)` and `.text()` on strings, `.precision(p, s)` on decimals, `.defaultNow()`, `.updatedAt()` and `.tz()` on datetimes.
+Kind-specific: `.maxLength(n)` and `.text()` on strings, `.precision(p, s)` on decimals, `.defaultNow()`, `.updatedAt()` and `.tz()` on datetimes. `.tz({ precision: 3 })` declares `@db.Timestamptz(3)`: it stores exactly what a JavaScript `Date` holds, so a database-written time reads back unchanged and `findPage` can order by the column without an assertion.
 
 ### Database defaults
 

package/dist/column.d.ts

@@ -77,8 +77,15 @@ export declare class ChainableDecimalColumn extends ChainableColumn<"decimal"> {
 /** DateTime column with timestamp-specific helpers. */
 export declare class ChainableDatetimeColumn extends ChainableColumn<"datetime"> {
     constructor(config?: DatetimeColumnConfig);
-    /** `@db.Timestamptz` — timezone-aware timestamp. */
-    tz(): this;
+    /**
+     * `@db.Timestamptz` — timezone-aware timestamp; `{ precision: n }` declares
+     * `@db.Timestamptz(n)` (0–6 fractional-seconds digits). Precision 3 stores
+     * exactly what a JavaScript `Date` holds, so a database-written value reads
+     * back unchanged and `findPage` may order by it without an assertion.
+     */
+    tz(options?: {
+        readonly precision?: number;
+    }): this;
     /** `@updatedAt` — refreshed on every update. */
     updatedAt(): this;
     /** `@default(now())` */
@@ -128,6 +135,7 @@ export declare function boolean(config?: BooleanColumnConfig): ChainableColumn<"
  *
  * @example
  * dsl.datetime().defaultNow().updatedAt().tz()
+ * dsl.datetime().defaultNow().tz({ precision: 3 })
  */
 export declare function datetime(config?: DatetimeColumnConfig): ChainableDatetimeColumn;
 /** Json column with a consumer-declared payload type (typed JSON). */

package/dist/index.js

@@ -94,8 +94,11 @@ class ChainableDatetimeColumn extends ChainableColumn {
   constructor(config = {}) {
     super("datetime", config);
   }
-  tz() {
+  tz(options) {
     this.__config.tz = true;
+    if (options?.precision !== undefined) {
+      this.__config.precision = options.precision;
+    }
     return this;
   }
   updatedAt() {
@@ -606,6 +609,10 @@ function evaluateIndexes(params) {
 }
 
 // packages/dsl/src/relation-plan.ts
+function relationPairKey(params) {
+  const { relation, reverse } = params;
+  return JSON.stringify(reverse ? [relation.__toModel, relation.__toColumns, relation.__fromModel, relation.__fromColumns, relation.__alias ?? ""] : [relation.__fromModel, relation.__fromColumns, relation.__toModel, relation.__toColumns, relation.__alias ?? ""]);
+}
 function detectOneToOnePairs(params) {
   const { relations, models } = params;
   const mergeMap = new Map;
@@ -620,6 +627,15 @@ function detectOneToOnePairs(params) {
       }
     }
   }
+  const candidatesByKey = new Map;
+  for (const [position, entry] of allOnes.entries()) {
+    const key = relationPairKey({ relation: entry.rel });
+    const bucket = candidatesByKey.get(key);
+    if (bucket === undefined)
+      candidatesByKey.set(key, { positions: [position], start: 0 });
+    else
+      bucket.positions.push(position);
+  }
   const paired = new Set;
   for (let i = 0;i < allOnes.length; i++) {
     const a = allOnes[i];
@@ -628,13 +644,17 @@ function detectOneToOnePairs(params) {
     const keyA = `${a.modelName}:${a.relName}`;
     if (paired.has(keyA))
       continue;
-    for (let j = i + 1;j < allOnes.length; j++) {
+    const bucket = candidatesByKey.get(relationPairKey({ relation: a.rel, reverse: true }));
+    if (bucket === undefined)
+      continue;
+    for (let candidate = bucket.start;candidate < bucket.positions.length; candidate++) {
+      const j = bucket.positions[candidate];
       const b = allOnes[j];
-      if (b === undefined)
-        continue;
       const keyB = `${b.modelName}:${b.relName}`;
-      if (paired.has(keyB))
+      if (j <= i || paired.has(keyB)) {
+        bucket.start = candidate + 1;
         continue;
+      }
       const sameColumnPair = a.rel.__fromModel === b.rel.__toModel && sameColumnTuple({ left: a.rel.__fromColumns, right: b.rel.__toColumns }) && a.rel.__toModel === b.rel.__fromModel && sameColumnTuple({ left: a.rel.__toColumns, right: b.rel.__fromColumns });
       if (!sameColumnPair || (a.rel.__alias ?? "") !== (b.rel.__alias ?? ""))
         continue;
@@ -662,6 +682,7 @@ function detectOneToOnePairs(params) {
       });
       paired.add(fkKey);
       paired.add(backKey);
+      bucket.start = candidate + 1;
       break;
     }
   }
@@ -762,7 +783,7 @@ function planExplicitRelations(params) {
   return planned;
 }
 function planMissingReverseRelations(params) {
-  const { modelName, relations, mergeMap, existing } = params;
+  const { modelName, relations, incoming, mergeMap, existing } = params;
   const planned = [];
   const existingLists = new Set;
   const existingNames = new Set;
@@ -772,44 +793,40 @@ function planMissingReverseRelations(params) {
       existingLists.add(`${relation.targetModel}:${relation.relationName ?? ""}`);
     }
   }
-  for (const [sourceModelName, sourceRelations] of Object.entries(relations)) {
-    for (const [relName, rel] of Object.entries(sourceRelations)) {
-      if (rel.__targetModel !== modelName || rel.__relationType !== "one")
-        continue;
-      if (mergeMap.has(`${sourceModelName}:${relName}`))
-        continue;
-      const reverseKey = `${sourceModelName}:${rel.__alias ?? ""}`;
-      if (existingLists.has(reverseKey))
+  for (const { modelName: sourceModelName, relName, rel } of incoming) {
+    if (mergeMap.has(`${sourceModelName}:${relName}`))
+      continue;
+    const reverseKey = `${sourceModelName}:${rel.__alias ?? ""}`;
+    if (existingLists.has(reverseKey))
+      continue;
+    if (sourceModelName === modelName) {
+      const hasExplicitReverse = Object.values(relations[sourceModelName] ?? {}).some((other) => other.__relationType === "many" && other.__targetModel === modelName && other.__alias === rel.__alias);
+      if (hasExplicitReverse)
         continue;
-      if (sourceModelName === modelName) {
-        const hasExplicitReverse = Object.values(sourceRelations).some((other) => other.__relationType === "many" && other.__targetModel === modelName && other.__alias === rel.__alias);
-        if (hasExplicitReverse)
-          continue;
-      }
-      const baseName = rel.__alias ?? sourceModelName;
-      let name = baseName;
-      let counter = 1;
-      while (existingNames.has(name)) {
-        counter++;
-        name = `${baseName}${counter}`;
-      }
-      planned.push({
-        model: modelName,
-        name,
-        targetModel: sourceModelName,
-        kind: "list",
-        isList: true,
-        isOptional: false,
-        relationName: rel.__alias
-      });
-      existingLists.add(reverseKey);
-      existingNames.add(name);
     }
+    const baseName = rel.__alias ?? sourceModelName;
+    let name = baseName;
+    let counter = 1;
+    while (existingNames.has(name)) {
+      counter++;
+      name = `${baseName}${counter}`;
+    }
+    planned.push({
+      model: modelName,
+      name,
+      targetModel: sourceModelName,
+      kind: "list",
+      isList: true,
+      isOptional: false,
+      relationName: rel.__alias
+    });
+    existingLists.add(reverseKey);
+    existingNames.add(name);
   }
   return planned;
 }
 function planChildRelations(params) {
-  const { modelName, model, models } = params;
+  const { modelName, model, parents } = params;
   const planned = [];
   for (const [childKey, childModel] of model.__children) {
     planned.push({
@@ -821,22 +838,18 @@ function planChildRelations(params) {
       isOptional: false
     });
   }
-  for (const [parentModelName, parentModel] of models) {
-    for (const childModel of parentModel.__children.values()) {
-      if (childModel.__name !== modelName)
-        continue;
-      const parentPk = parentModel.__primaryKey?.[0] ?? Array.from(parentModel.__columns.entries()).find(([, column]) => column.__columnType === "id")?.[0] ?? "id";
-      planned.push({
-        model: modelName,
-        name: parentModelName,
-        targetModel: parentModelName,
-        kind: "fkOwner",
-        isList: false,
-        isOptional: false,
-        fields: [toFkColumnName({ modelName: parentModelName })],
-        references: [parentPk]
-      });
-    }
+  for (const [parentModelName, parentModel] of parents) {
+    const parentPk = parentModel.__primaryKey?.[0] ?? Array.from(parentModel.__columns.entries()).find(([, column]) => column.__columnType === "id")?.[0] ?? "id";
+    planned.push({
+      model: modelName,
+      name: parentModelName,
+      targetModel: parentModelName,
+      kind: "fkOwner",
+      isList: false,
+      isOptional: false,
+      fields: [toFkColumnName({ modelName: parentModelName })],
+      references: [parentPk]
+    });
   }
   return planned;
 }
@@ -960,6 +973,33 @@ function assertForeignKeyIntegrity(params) {
     refuse(`references ${relation.targetModel}.(${references.join(", ")}), which is not a unique key there \u2014 declare those columns as the primary key, a unique column, or a total @@unique index`, "relation-reference-not-unique", { references, candidates: keys.map((key) => [...key]) });
   }
 }
+function relationLookups(params) {
+  const incoming = new Map;
+  for (const [modelName, relations] of Object.entries(params.schema.__relations)) {
+    for (const [relName, rel] of Object.entries(relations)) {
+      if (rel.__relationType !== "one")
+        continue;
+      const target = rel.__targetModel;
+      const entries = incoming.get(target);
+      const entry = { modelName, relName, rel };
+      if (entries === undefined)
+        incoming.set(target, [entry]);
+      else
+        entries.push(entry);
+    }
+  }
+  const parents = new Map;
+  for (const [name, model] of params.schema.__models) {
+    for (const child of model.__children.values()) {
+      const entries = parents.get(child.__name);
+      if (entries === undefined)
+        parents.set(child.__name, [[name, model]]);
+      else
+        entries.push([name, model]);
+    }
+  }
+  return { incoming, parents };
+}
 function planSchema(params) {
   const { schema } = params;
   const mergeMap = detectOneToOnePairs({
@@ -968,7 +1008,13 @@ function planSchema(params) {
   });
   const relations = new Map;
   const indexes = new Map;
+  let lookups = relationLookups({ schema });
+  let refreshLookups = false;
   for (const [modelName, model] of schema.__models) {
+    if (refreshLookups) {
+      lookups = relationLookups({ schema });
+      refreshLookups = false;
+    }
     const explicit = planExplicitRelations({
       modelName,
       model,
@@ -978,16 +1024,22 @@ function planSchema(params) {
     const reverses = planMissingReverseRelations({
       modelName,
       relations: schema.__relations,
+      incoming: lookups.incoming.get(modelName) ?? [],
       mergeMap,
       existing: explicit
     });
-    const children = planChildRelations({ modelName, model, models: schema.__models });
+    const children = planChildRelations({ modelName, model, parents: lookups.parents.get(modelName) ?? [] });
     const planned = [...explicit, ...reverses, ...children];
     for (const relation of planned) {
-      if (relation.kind === "fkOwner")
+      if (relation.kind === "fkOwner") {
+        if (schema.__models.get(relation.targetModel)?.__indexes !== undefined)
+          refreshLookups = true;
         assertForeignKeyIntegrity({ relation, models: schema.__models });
+      }
     }
     relations.set(modelName, planned);
+    if (model.__indexes !== undefined)
+      refreshLookups = true;
     indexes.set(modelName, planIndexes({ model }));
   }
   return { relations, indexes };
@@ -1077,6 +1129,20 @@ function fieldDefault(params) {
     return { kind: "literal", value: exactIntegerLiteral({ text: value.toString() }) };
   throw new VibeError4({ code: "VIBE_SCHEMA_INVALID", message: `Unsupported default for ${column.__columnType}` });
 }
+function datetimeNativeType(params) {
+  const { tz, precision } = params.config;
+  if (precision !== undefined && (tz !== true || !Number.isInteger(precision) || precision < 0 || precision > 6)) {
+    const at = params.column === undefined ? "A datetime column" : `Column "${params.column}"`;
+    throw new VibeError4({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `${at}: a datetime precision must be an integer from 0 to 6 on a tz() column, as in dsl.datetime().tz({ precision: 3 })`,
+      meta: { issues: [{ rule: "datetime-precision", column: params.column, precision, tz: tz === true }] }
+    });
+  }
+  if (tz !== true)
+    return;
+  return precision === undefined ? "Timestamptz" : `Timestamptz(${precision})`;
+}
 function nativeType(params) {
   const { column } = params;
   if (column.__columnType === "enum") {
@@ -1106,8 +1172,8 @@ function nativeType(params) {
       return `Decimal(${precision}, ${scale ?? 0})`;
     return;
   }
-  if (column.__columnType === "datetime" && column.__config.tz === true) {
-    return "Timestamptz";
+  if (column.__columnType === "datetime") {
+    return datetimeNativeType({ config: column.__config, column: column.__name });
   }
   if (column.__columnType === "unsupported") {
     return String(column.__config.dbType);
@@ -1419,8 +1485,9 @@ function nativeTypeAttribute(params) {
       return `@db.Decimal(${precision}, ${scale ?? 0})`;
     return;
   }
-  if (column.__columnType === "datetime" && column.__config.tz === true) {
-    return "@db.Timestamptz";
+  if (column.__columnType === "datetime") {
+    const native = datetimeNativeType({ config: column.__config, column: column.__name });
+    return native === undefined ? undefined : `@db.${native}`;
   }
   return;
 }
@@ -2267,4 +2334,4 @@ export {
   withNameDescription
 };
 
-//# debugId=9B3711B7350090C264756E2164756E21
+//# debugId=AC91338749EBA17764756E2164756E21