@vibeorm/migrate 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/index.js

@@ -74,9 +74,12 @@ function detectImplicitM2MPairs(params) {
       const target = modelsByName.get(relation.targetModel);
       if (target === undefined || target.isView)
         continue;
-      const counterpart = target.relations.find((candidate) => candidate !== relation && candidate.targetModel === model.name && isFieldlessListSide({ relation: candidate }) && candidate.relationName === relation.relationName);
-      if (counterpart === undefined)
+      const counterpart = soleCounterpart({ relation, ownModel: model.name, target });
+      if (counterpart === undefined || !isFieldlessListSide({ relation: counterpart }))
         continue;
+      if (soleCounterpart({ relation: counterpart, ownModel: target.name, target: model }) !== relation) {
+        continue;
+      }
       const joinTable = implicitJoinTable({
         modelA: model.name,
         modelB: relation.targetModel,
@@ -99,6 +102,11 @@ function isFieldlessListSide(params) {
   const { relation } = params;
   return relation.isList && (relation.fields === undefined || relation.fields.length === 0);
 }
+function soleCounterpart(params) {
+  const { relation, ownModel, target } = params;
+  const candidates = target.relations.filter((candidate) => candidate !== relation && candidate.targetModel === ownModel && candidate.relationName === relation.relationName);
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
 
 // packages/migrate/src/postgres-types.ts
 import { VibeError, isEnumType } from "@vibeorm/schema";
@@ -110,10 +118,13 @@ var SCALAR_TO_PG = {
   BigInt: "bigint",
   Float: "double precision",
   Decimal: "numeric",
-  DateTime: "timestamptz(3)",
+  DateTime: "timestamptz",
   Json: "jsonb",
   Bytes: "bytea"
 };
+var CANONICAL_EQUIVALENTS = {
+  DateTime: ["timestamptz(3)", "timestamptz(6)"]
+};
 var NATIVE_ALIASES = {
   charactervarying: "varchar",
   character: "char",
@@ -155,7 +166,8 @@ function columnTypeKey(params) {
   if (field.nativeType !== undefined) {
     const normalized = normalizeNativeType({ raw: field.nativeType });
     const canonical = normalizeNativeType({ raw: SCALAR_TO_PG[field.type] });
-    if (normalized !== canonical)
+    const isCanonical = normalized === canonical || (CANONICAL_EQUIVALENTS[field.type]?.includes(normalized) ?? false);
+    if (!isCanonical)
       return `n:${normalized}${listSuffix}`;
   }
   return `s:${field.type}${listSuffix}`;
@@ -219,6 +231,9 @@ function defaultFingerprint(params) {
         return `num:${value}`;
       if (isEnumType(field.type))
         return `enum:${value}`;
+      if (isNumericScalar({ type: field.type }) && NUMERIC_LITERAL.test(value)) {
+        return `num:${Number(value)}`;
+      }
       return `str:${value}`;
     }
     case "enumValue":
@@ -254,6 +269,11 @@ function defaultSql(params) {
       return def.sql;
   }
 }
+var NUMERIC_LITERAL = /^-?\d+(\.\d+)?$/;
+function isNumericScalar(params) {
+  const { type } = params;
+  return type === "Int" || type === "BigInt" || type === "Float" || type === "Decimal";
+}
 var PG_CHAR_TO_CASCADE_ACTION = {
   a: "NoAction",
   r: "Restrict",
@@ -2330,6 +2350,7 @@ function addFkRelations(params) {
   const modelsByName = new Map(models.map((model) => [model.name, model]));
   const relationsByModel = new Map;
   const takeName = nameAllocator({ models });
+  const ambiguousPairs = detectAmbiguousPairs({ fkGroups, joinTables, modelsByName });
   for (const group of fkGroups) {
     if (joinTables.has(group.table))
       continue;
@@ -2337,6 +2358,7 @@ function addFkRelations(params) {
     const target = modelsByName.get(group.refTable);
     if (owner === undefined || target === undefined)
       continue;
+    const relationName = ambiguousPairs.has(modelPairKey({ a: group.table, b: group.refTable })) ? `${group.table}_${group.columns.join("_")}To${group.refTable}` : undefined;
     const fkSide = {
       name: takeName({ model: owner.name, base: lowerFirst(group.refTable) }),
       model: owner.name,
@@ -2347,7 +2369,8 @@ function addFkRelations(params) {
       onDelete: group.onDelete,
       onUpdate: group.onUpdate,
       isList: false,
-      isOptional: !group.required
+      isOptional: !group.required,
+      ...relationName === undefined ? {} : { relationName }
     };
     pushRelation({ relationsByModel, relation: fkSide });
     const listSide = {
@@ -2356,7 +2379,8 @@ function addFkRelations(params) {
       targetModel: group.table,
       type: "oneToMany",
       isList: true,
-      isOptional: false
+      isOptional: false,
+      ...relationName === undefined ? {} : { relationName }
     };
     pushRelation({ relationsByModel, relation: listSide });
   }
@@ -2400,6 +2424,30 @@ function addJoinTableRelations(params) {
   }
   applyRelations({ models, relationsByModel });
 }
+function modelPairKey(params) {
+  const { a, b } = params;
+  return [a, b].sort().join("\x00");
+}
+function detectAmbiguousPairs(params) {
+  const { fkGroups, joinTables, modelsByName } = params;
+  const counts = new Map;
+  const bump = (key) => {
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  };
+  for (const group of fkGroups) {
+    if (joinTables.has(group.table))
+      continue;
+    if (!modelsByName.has(group.table) || !modelsByName.has(group.refTable))
+      continue;
+    bump(modelPairKey({ a: group.table, b: group.refTable }));
+  }
+  for (const [, joinTable] of joinTables) {
+    if (joinTable.relationName !== undefined)
+      continue;
+    bump(modelPairKey({ a: joinTable.tableA, b: joinTable.tableB }));
+  }
+  return new Set([...counts.entries()].filter(([, count]) => count > 1).map(([key]) => key));
+}
 function pushRelation(params) {
   const { relationsByModel, relation } = params;
   const list = relationsByModel.get(relation.model);
@@ -2500,17 +2548,18 @@ var COLUMNS_QUERY = `
 `;
 var CONSTRAINTS_QUERY = `
   SELECT
-    tc.constraint_name,
-    tc.constraint_type,
-    tc.table_name,
-    kcu.column_name
-  FROM information_schema.table_constraints tc
-  JOIN information_schema.key_column_usage kcu
-    ON tc.constraint_name = kcu.constraint_name
-    AND tc.table_schema = kcu.table_schema
-  WHERE tc.table_schema = 'public'
-    AND tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE')
-  ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position;
+    c.conname AS constraint_name,
+    CASE c.contype WHEN 'p' THEN 'PRIMARY KEY' ELSE 'UNIQUE' END AS constraint_type,
+    cl.relname AS table_name,
+    att.attname AS column_name
+  FROM pg_catalog.pg_constraint c
+  JOIN pg_catalog.pg_class cl    ON cl.oid = c.conrelid
+  JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
+  JOIN unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+  JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = k.attnum
+  WHERE c.contype IN ('p', 'u')
+    AND n.nspname = 'public'
+  ORDER BY cl.relname, c.conname, k.ord;
 `;
 var FOREIGN_KEYS_QUERY = `
   SELECT
@@ -2821,7 +2870,7 @@ function nonCanonicalModifier(params) {
   const { column, udt, scalar } = params;
   if (scalar === "DateTime" && udt === "timestamptz") {
     const precision = column.datetimePrecision;
-    return precision === null || precision === 3 ? undefined : `timestamptz(${precision})`;
+    return precision === null || precision === 6 ? undefined : `timestamptz(${precision})`;
   }
   if (scalar === "Decimal" && udt === "numeric") {
     if (column.numericPrecision === null)
@@ -2876,10 +2925,6 @@ function parseColumnDefault(params) {
   }
   return { kind: "dbgenerated", sql: raw };
 }
-function isNumericScalar(params) {
-  const { type } = params;
-  return type === "Int" || type === "BigInt" || type === "Float" || type === "Decimal";
-}
 function parseIndexDef(params) {
   const { table, name, def } = params;
   const head = def.match(/^CREATE (UNIQUE )?INDEX .*? USING (\w+) \(/);
@@ -3810,4 +3855,4 @@ export {
   MIGRATIONS_TABLE_NAME
 };
 
-//# debugId=3CDFCCD15C21DD9464756E2164756E21
+//# debugId=5088DA7EA679FA1464756E2164756E21