@vibeorm/migrate 2.6.0 → 2.7.0

package/dist/fs.js

@@ -172,6 +172,9 @@ var SCALAR_TO_PG = {
 var CANONICAL_EQUIVALENTS = {
   DateTime: ["timestamptz(3)", "timestamptz(6)"]
 };
+var EXACT_CANONICAL_EQUIVALENTS = {
+  DateTime: ["timestamptz(6)"]
+};
 var CANONICAL_UDT = {
   text: "String",
   bool: "Boolean",
@@ -240,13 +243,15 @@ var NATIVE_ALIASES = {
 var IMPLICIT_MODIFIERS = {
   bit: "(1)"
 };
+var DEFAULT_PRECISION_SIX = new Set(["timestamp", "time", "timetz"]);
 function normalizeNativeType(params) {
   const compact = params.raw.toLowerCase().replace(/\s+/g, "");
   const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(\[\])?$/);
   if (match === null)
     return compact;
   const base = NATIVE_ALIASES[match[1]] ?? match[1];
-  return `${base}${match[2] ?? IMPLICIT_MODIFIERS[base] ?? ""}${match[3] ?? ""}`;
+  const modifier = DEFAULT_PRECISION_SIX.has(base) && match[2] === "(6)" ? "" : match[2] ?? IMPLICIT_MODIFIERS[base] ?? "";
+  return `${base}${modifier}${match[3] ?? ""}`;
 }
 function parseUnsupportedPostgresType(params) {
   const temporal = /^\s*(time(?:stamp)?)\s*(\(\s*\d+\s*\))?\s+(with|without)\s+time\s+zone\s*((?:\[\s*\]\s*)*)$/i.exec(params.raw);
@@ -259,7 +264,7 @@ function parseUnsupportedPostgresType(params) {
   return NATIVE_ALIASES[base] === undefined ? undefined : parsePostgresTypeName({ raw: normalizeNativeType(params) });
 }
 function columnTypeKey(params) {
-  const { field } = params;
+  const { field, exact } = params;
   const listSuffix = field.isList ? "[]" : "";
   if (field.isUnsupported === true) {
     const parsed = parseUnsupportedPostgresType({ raw: field.nativeType ?? "" });
@@ -270,7 +275,7 @@ function columnTypeKey(params) {
     const scalar = namespace === undefined || namespace === "pg_catalog" ? scalarForBuiltinType({ name: parsed.name }) : undefined;
     if (scalar !== undefined) {
       const { isUnsupported: _unsupported, nativeTypeIdentity: _identity, ...rest } = field;
-      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList } });
+      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList }, ...exact === undefined ? {} : { exact } });
     }
     return `u:${JSON.stringify([namespace ?? null, parsed.name, parsed.modifier, parsed.array || field.isList])}`;
   }
@@ -281,12 +286,37 @@ function columnTypeKey(params) {
   if (field.nativeType !== undefined) {
     const normalized = normalizeNativeType({ raw: field.nativeType });
     const canonical = normalizeNativeType({ raw: SCALAR_TO_PG[field.type] });
-    const isCanonical = normalized === canonical || (CANONICAL_EQUIVALENTS[field.type]?.includes(normalized) ?? false);
+    const equivalents = exact === true ? EXACT_CANONICAL_EQUIVALENTS : CANONICAL_EQUIVALENTS;
+    const isCanonical = normalized === canonical || (equivalents[field.type]?.includes(normalized) ?? false);
     if (!isCanonical)
       return `n:${normalized}${listSuffix}`;
   }
   return `s:${field.type}${listSuffix}`;
 }
+function declaresExactColumnType(params) {
+  const { field } = params;
+  if (field.isUnsupported === true || field.nativeType === undefined || isEnumType(field.type))
+    return false;
+  return CANONICAL_EQUIVALENTS[field.type]?.includes(normalizeNativeType({ raw: field.nativeType })) ?? false;
+}
+function timestamptzPrecision(params) {
+  const { field } = params;
+  if (field.type !== "DateTime" || field.isUnsupported === true)
+    return;
+  const normalized = field.nativeType === undefined ? "timestamptz" : normalizeNativeType({ raw: field.nativeType });
+  if (normalized === "timestamptz")
+    return 6;
+  const match = /^timestamptz\((\d)\)$/.exec(normalized);
+  return match === null ? undefined : Number(match[1]);
+}
+function isTimestamptzPrecisionWidening(params) {
+  const { from, to } = params;
+  if (from.isList !== to.isList)
+    return false;
+  const before = timestamptzPrecision({ field: from });
+  const after = timestamptzPrecision({ field: to });
+  return before !== undefined && after !== undefined && after >= before;
+}
 function isScalarToArrayChange(params) {
   const { from, to } = params;
   if (from.isList || !to.isList)
@@ -829,16 +859,20 @@ function assertStringEnumLabelsFit(params) {
   }
 }
 function columnTypeKeyFor(params) {
-  const { field, dialect, enums } = params;
+  const { field, dialect, enums, exact } = params;
   switch (dialect) {
     case "postgres":
-      return columnTypeKey({ field });
+      return columnTypeKey({ field, ...exact === undefined ? {} : { exact } });
     case "sqlite":
       return sqliteColumnTypeKey({ field, enums });
     case "mysql":
       return mysqlColumnTypeKey({ field, enums });
   }
 }
+function columnTypeChanged(params) {
+  const { declared, actual } = params;
+  return declared.pinsExactType ? declared.exactTypeKey !== actual.exactTypeKey : declared.typeKey !== actual.typeKey;
+}
 function defaultFingerprintFor(params) {
   const { field, dialect } = params;
   switch (dialect) {
@@ -861,6 +895,8 @@ function normalizeModel(params) {
       name,
       field,
       typeKey: columnTypeKeyFor({ field, dialect, enums }),
+      exactTypeKey: columnTypeKeyFor({ field, dialect, enums, exact: true }),
+      pinsExactType: dialect === "postgres" && declaresExactColumnType({ field }),
       nullable: field.isOptional,
       defaultKey: defaultFingerprintFor({ field, dialect })
     });
@@ -2720,8 +2756,9 @@ function reverseMapType(params) {
 function nonCanonicalModifier(params) {
   const { column, udt, scalar } = params;
   if (column.dataType === "ARRAY" && column.fullType !== null) {
-    const element = normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
-    if (/^(numeric|timestamptz)\([\d,]+\)$/.test(element))
+    const temporal = parseUnsupportedPostgresType({ raw: column.fullType });
+    const element = temporal?.name === "timestamptz" ? `timestamptz${temporal.modifier}` : normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
+    if (element !== "timestamptz(6)" && /^(numeric|timestamptz)\([\d,]+\)$/.test(element))
       return element;
   }
   if (scalar === "DateTime" && udt === "timestamptz") {
@@ -2738,9 +2775,9 @@ function nonCanonicalModifier(params) {
 }
 function withModifier(params) {
   const { column, udt } = params;
-  if (udt === "varchar" && column.dataType === "ARRAY" && column.fullType !== null) {
+  if ((udt === "varchar" || udt === "bpchar" || udt === "bit" || udt === "varbit") && column.dataType === "ARRAY" && column.fullType !== null) {
     const elementType = normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
-    if (/^varchar\(\d+\)$/.test(elementType))
+    if (/^(varchar|char|bit|varbit)\(\d+\)$/.test(elementType))
       return elementType;
   }
   if ((udt === "varchar" || udt === "bpchar") && column.charMaxLength !== null) {
@@ -2750,6 +2787,10 @@ function withModifier(params) {
     return "char";
   if ((udt === "bit" || udt === "varbit") && column.charMaxLength !== null)
     return `${udt}(${column.charMaxLength})`;
+  if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.dataType === "ARRAY" && column.fullType !== null) {
+    const element = parseUnsupportedPostgresType({ raw: column.fullType });
+    return element === undefined || element.modifier === "" || element.modifier === "(6)" ? udt : `${udt}${element.modifier}`;
+  }
   if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
     return `${udt}(${column.datetimePrecision})`;
   }
@@ -4248,7 +4289,8 @@ async function verifySchemaObjects(params) {
     pin("primaryKey", desired.pk, live.pk);
     for (const [column, field] of desired.columns) {
       const stored = live.columns.get(column);
-      pin(`columns.${column}.type`, field.typeKey, stored?.typeKey);
+      const exactType = field.pinsExactType;
+      pin(`columns.${column}.type`, exactType ? field.exactTypeKey : field.typeKey, exactType ? stored?.exactTypeKey : stored?.typeKey);
       pin(`columns.${column}.nullable`, field.nullable, stored?.nullable);
       if (params.dialect === "mysql" && field.field.collation !== undefined) {
         pin(`columns.${column}.collation`, field.field.collation.toLowerCase(), stored?.field.collation?.toLowerCase());
@@ -6044,7 +6086,7 @@ function diffOneTable(params) {
       continue;
     }
     const changes = [];
-    if (before.typeKey !== column.typeKey)
+    if (columnTypeChanged({ declared: column, actual: before }))
       changes.push("type");
     if (before.nullable !== column.nullable)
       changes.push("nullability");
@@ -6067,7 +6109,7 @@ function diffOneTable(params) {
           assertStringEnumLabelsFit({ field: column.field, values, dialect, table });
       }
     }
-    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field }) && !(storageChange && column.field.type === "String");
+    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field }) && !(dialect === "postgres" && isTimestamptzPrecisionWidening({ from: before.field, to: column.field })) && !(storageChange && column.field.type === "String");
     if (dialect !== "postgres" && changes.includes("type") && isEnumType6(before.field.type) && isEnumType6(column.field.type)) {
       const fromValues = resolveEnumValues({ name: before.field.type.enum, enums: fromEnums });
       const toValues = resolveEnumValues({ name: column.field.type.enum, enums: toEnums });
@@ -8701,4 +8743,4 @@ export {
   splitSqlStatements
 };
 
-//# debugId=91A1E2329350564C64756E2164756E21
+//# debugId=000F8CFDEDF957F264756E2164756E21