@drzl/analyzer 1.18.0 → 1.20.0

package/dist/index.js

@@ -1,4 +1,10 @@
 // src/index.ts
+function qualifiedTableName(table) {
+  return table.schema ? `${table.schema}.${table.name}` : table.name;
+}
+function qualifiedForeignTable(fk) {
+  return fk.foreignSchema ? `${fk.foreignSchema}.${fk.foreignTable}` : fk.foreignTable;
+}
 function renderSqlLiteral(v) {
   if (v === null || v === void 0) return "NULL";
   if (typeof v === "number" || typeof v === "bigint") return String(v);
@@ -30,15 +36,23 @@ var GEOMETRIC_CLASS_SHAPES = {
   // The object modes. `line({ mode: 'abc' })` is a `PgLineABC` and not a `PgLineObject`, and any
   // mode but `'tuple'` builds the object class: `point({ mode: 'abc' })` is a `PgPointObject` too.
   PgPointObject: { kind: "numberObject", fields: ["x", "y"] },
-  PgLineABC: { kind: "numberObject", fields: ["a", "b", "c"] }
+  PgLineABC: { kind: "numberObject", fields: ["a", "b", "c"] },
+  // `geometry()` and `geometry({ mode: 'xy' })` are two classes, not one class with a flag, and
+  // the fuzzer found both unnamed on this path. Their driver mappers disagree the same way the
+  // point ones do: the default hands back `[1, 2]` and the xy mode hands back `{ x: 1, y: 2 }`.
+  PgGeometry: { kind: "tuple", length: 2 },
+  PgGeometryObject: { kind: "numberObject", fields: ["x", "y"] }
 };
 var V1_ONLY_ENTITY_KINDS = /^(?:MsSql|Cockroach)/;
+var NUMBER_VECTOR_CLASSES = /* @__PURE__ */ new Set(["PgVector", "PgHalfVector", "SingleStoreVector"]);
+var BIT_STRING_CLASSES = /* @__PURE__ */ new Set(["PgBinaryVector"]);
 var BYTE_STRING_CLASSES = /* @__PURE__ */ new Set([
   "MySqlBinary",
   "MySqlVarBinary",
   "SingleStoreBinary",
   "SingleStoreVarBinary"
 ]);
+var BUFFER_CLASSES = /* @__PURE__ */ new Set(["SQLiteBlobBuffer"]);
 function describeV1Column(column) {
   const codec = column?.codec;
   const dataType = column?.dataType;
@@ -57,14 +71,24 @@ function describeV1Column(column) {
   const out = {};
   switch (semantic) {
     case "int8":
+    case "uint8":
     case "int16":
     case "int24":
     case "int32":
     case "int53":
     case "uint53":
     case "int64": {
+      if (DECIMAL_BIGINT_MODE.test(entityKind)) {
+        out.tsType = "bigint";
+        out.dbType = "NUMERIC";
+        out.integer = true;
+        const range2 = decimalModeRange(column, entityKind, "bigint");
+        if (range2) [out.min, out.max] = range2;
+        break;
+      }
       const range = {
         int8: ["-128", "127"],
+        uint8: ["0", "255"],
         int16: ["-32768", "32767"],
         int24: ["-8388608", "8388607"],
         int32: ["-2147483648", "2147483647"],
@@ -77,7 +101,7 @@ function describeV1Column(column) {
       [out.min, out.max] = range;
       out.integer = true;
       out.tsType = js === "bigint" ? "bigint" : "number";
-      out.dbType = semantic === "int8" ? "TINYINT" : semantic === "int16" ? "SMALLINT" : semantic === "int24" ? "MEDIUMINT" : semantic === "int32" ? "INTEGER" : "BIGINT";
+      out.dbType = semantic === "int8" || semantic === "uint8" ? "TINYINT" : semantic === "int16" ? "SMALLINT" : semantic === "int24" ? "MEDIUMINT" : semantic === "int32" ? "INTEGER" : "BIGINT";
       break;
     }
     case "year":
@@ -93,6 +117,10 @@ function describeV1Column(column) {
       out.integer = false;
       out.tsType = "number";
       out.dbType = semantic === "float" ? "REAL" : "DOUBLE";
+      if (codec === "float4" || codec === "float8") {
+        out.allowsNaN = true;
+        out.allowsInfinity = true;
+      }
       break;
     }
     case "uuid":
@@ -122,6 +150,16 @@ function describeV1Column(column) {
       out.dbType = codec?.startsWith("timestamp") ? "TIMESTAMP" : "DATE";
       break;
     case "timestamp":
+    // `datetime` is the same fact under MySQL's name for it, and it had no arm, so every column
+    // stating it fell to the bare-string arm and was labelled TEXT. The columns that reach this
+    // are the string modes of `datetime` on mssql, mysql and singlestore, plus mssql's
+    // `datetime2` and `datetimeoffset`, swept over every builder the six v1 cores export; the
+    // `{ mode: 'date' }` half of the same builders states `object date` and takes the arm above.
+    // A label only, since `dbType` is read outside this file in exactly one place,
+    // `isIntegerColumn`, which the generators consult for a `tsType` of `number`. It matters
+    // because the class-name path already answers TIMESTAMP for the same 0.4x column, and the
+    // two majors disagreeing about a column is what the cross-major diff exists to catch.
+    case "datetime":
       out.tsType = js === "string" ? "string" : "Date";
       out.dbType = "TIMESTAMP";
       break;
@@ -143,13 +181,25 @@ function describeV1Column(column) {
       const entity = String(column?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? "");
       const bytes = entity.startsWith("MySql") || entity.startsWith("SingleStore");
       out.tsType = "string";
-      out.dbType = codec === "bit" ? "BIT" : "BINARY";
+      out.dbType = bytes ? "BINARY" : "BIT";
       out.shape = bytes ? { kind: "byteString", length: declaredLength(column) } : {
         kind: "bitstring",
         length: declaredLength(column),
         // A Postgres `bit(3)` holds exactly three digits; a Cockroach `varbit(16)` holds at
         // most that many, which is why `''` is valid there and not here.
-        exact: codec === "bit"
+        //
+        // `codec === 'bit'` alone was Postgres's answer applied to everything, and Cockroach
+        // states no codec, so both of its builders came back `exact: false` and a `bit(3)`
+        // was indistinguishable from a `varbit(3)`. Measured on CockroachDB v24.3.5: a
+        // `bit(3)` refuses '', '1', '10' and '1011' with "bit string length n does not match
+        // type BIT(3)" and takes '101'; a `varbit(8)` takes '', '1' and '10101010' and
+        // refuses nine digits with "too large for type VARBIT(8)". `drizzle-orm/zod` at
+        // 1.0.0-rc.4 answers the same for both columns.
+        //
+        // The class rather than a prefix, because `CockroachVarbit` starts with neither
+        // `CockroachBit` nor anything else this could key on without catching the varying
+        // half too.
+        exact: codec === "bit" || entity === "CockroachBit"
       };
       break;
     }
@@ -175,7 +225,16 @@ function describeV1Column(column) {
       out.dbType = "LINE";
       out.shape = js === "object" ? { kind: "numberObject", fields: ["a", "b", "c"] } : { kind: "tuple", length: 3 };
       break;
+    // `halfvec` beside `vector`, because they differ in storage width and in nothing a validator
+    // can see: `mapFromDriverValue` on both hands back `[1, 2, 3]`. It had no arm and came back
+    // `unknown` on this path too, which the fuzzer found.
+    //
+    // `sparsevec` is deliberately not here. Its name says vector and its value is the string
+    // `{1:1.5,3:2}/3`, so typing it `number[]` for symmetry would reject every row the database
+    // returns. Its codec already answers `string` on its own, which is the same conclusion reached
+    // without this arm.
     case "vector":
+    case "halfvec":
       out.tsType = "number[]";
       out.dbType = "VECTOR";
       out.shape = { kind: "numberVector", length: declaredLength(column) };
@@ -192,7 +251,12 @@ function describeV1Column(column) {
         out.tsType = "number";
         out.dbType = "NUMERIC";
         out.integer = false;
-        [out.min, out.max] = JS_SAFE_INTEGER_BOUNDS;
+        const range = decimalModeRange(column, entityKind, "number");
+        if (range) [out.min, out.max] = range;
+        if (codec === "numeric:number") {
+          out.allowsNaN = true;
+          out.allowsInfinity = !declaredDecimalRange(column);
+        }
       } else if (js === "string") {
         out.tsType = "string";
         out.dbType = codec === "varchar" ? "VARCHAR" : codec === "char" ? "CHAR" : "TEXT";
@@ -220,6 +284,28 @@ function declaredLength(column) {
   const n = column?.length ?? column?.config?.length ?? column?.config?.dimensions;
   return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : void 0;
 }
+function declaredDecimalRange(column) {
+  const cfg = column?.config ?? {};
+  const precision = column?.precision ?? cfg.precision;
+  const scale = column?.scale ?? cfg.scale ?? 0;
+  if (typeof precision !== "number" || !Number.isInteger(precision) || precision < 1)
+    return void 0;
+  if (typeof scale !== "number" || !Number.isInteger(scale) || scale < 0) return void 0;
+  const nines = "9".repeat(precision);
+  const max = scale === 0 ? nines : scale < precision ? `${nines.slice(0, precision - scale)}.${nines.slice(precision - scale)}` : `0.${"0".repeat(scale - precision)}${nines}`;
+  return [`-${max}`, max];
+}
+var DECIMAL_NUMBER_MODE = /(?:Numeric|Decimal)Number$/;
+var DECIMAL_BIGINT_MODE = /(?:Numeric|Decimal)BigInt$/;
+var MYSQL_IMPLICIT_DECIMAL_RANGE = ["-9999999999", "9999999999"];
+function decimalModeRange(column, kind, mode) {
+  const declared = declaredDecimalRange(column);
+  if (declared) return declared;
+  if (kind.startsWith("MySql") || kind.startsWith("SingleStore"))
+    return MYSQL_IMPLICIT_DECIMAL_RANGE;
+  if (kind.startsWith("SQLite")) return void 0;
+  return mode === "number" ? JS_SAFE_INTEGER_BOUNDS : void 0;
+}
 var VIEW_CONFIG_FIELDS = {
   "drizzle:Columns": "selectedFields",
   "drizzle:Name": "name",
@@ -264,27 +350,43 @@ function isRelationsV2(val) {
     )
   );
 }
+function qualifiedNameOfDrizzleTable(tbl) {
+  const name = getSymbolOf(tbl, "drizzle:Name");
+  if (typeof name !== "string" || !name) return void 0;
+  const schema = getSymbolOf(tbl, "drizzle:Schema");
+  return typeof schema === "string" && schema ? `${schema}.${name}` : name;
+}
 function readRelationsV2(val, issues = []) {
   const out = [];
   for (const [tableKey, entry] of Object.entries(val)) {
-    const from = getSymbolOf(entry.table, "drizzle:Name") ?? entry.name ?? tableKey;
+    const from = qualifiedNameOfDrizzleTable(entry.table) ?? entry.name ?? tableKey;
     for (const [fieldName, r] of Object.entries(entry.relations ?? {})) {
-      const to = r?.targetTableName;
+      const to = qualifiedNameOfDrizzleTable(r?.targetTable) ?? r?.targetTableName;
       if (typeof to !== "string" || !to) {
         issues.push({
           code: "DRZL_ANL_REL_V2",
           level: "warn",
-          message: `Relation "${fieldName}" on "${from}" names no target table and was skipped.`
+          message: `Relation "${fieldName}" on "${from}" names no target table and was skipped.`,
+          path: from
         });
         continue;
       }
-      const via = getSymbolOf(r.throughTable, "drizzle:Name") ?? getSymbolOf(r.through?.sourceTable, "drizzle:Name") ?? void 0;
+      const via = qualifiedNameOfDrizzleTable(r.throughTable) ?? qualifiedNameOfDrizzleTable(r.through?.sourceTable) ?? void 0;
       if (via) out.push({ kind: "manyToMany", from, to, via });
       else out.push({ kind: r.relationType === "many" ? "many" : "one", from, to });
     }
   }
   return out;
 }
+function unknownColumnHint(reason) {
+  if (reason === "custom") {
+    return "A customType has no runtime shape to read. Declare it with .$type<T>() and turn on typedColumns to give the validator the type.";
+  }
+  if (reason === "gel-temporal") {
+    return "A Gel temporal column holds an instance of a class from the `gel` package, which DRZL cannot import, so it is left untyped on purpose rather than guessed at. Turn on typedColumns to recover the declared type, and validate the value yourself.";
+  }
+  return "Open an issue naming the column type so it can be modelled, or declare it with .$type<T>() and turn on typedColumns.";
+}
 var _SchemaAnalyzer = class _SchemaAnalyzer {
   constructor(schemaPath) {
     this.schemaPath = schemaPath;
@@ -335,6 +437,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         code: "DRZL_ANL_EXTRACONFIG",
         level: "warn",
         message: `Could not evaluate the extra-config callback for table "${tableName}": ${e.message}`,
+        path: tableName,
         hint: "Indexes, composite keys, checks and table-level foreign keys will be missing for this table."
       });
       return [];
@@ -388,9 +491,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     };
     const foreignColumnsObj = this.getSymbol(ref.foreignTable, "drizzle:Columns") ?? {};
     const toForeignTs = this.dbToTsNames(foreignColumnsObj);
+    const foreignSchema = this.getSymbol(ref.foreignTable, "drizzle:Schema");
     return {
       columns: (ref.columns ?? []).map((c) => toTs(c?.name)),
       foreignTable: this.getSymbol(ref.foreignTable, "drizzle:Name") ?? "unknown",
+      ...foreignSchema ? { foreignSchema } : {},
       foreignColumns: (ref.foreignColumns ?? []).map((c) => toForeignTs(c?.name)),
       onDelete: action(fk?.onDelete, fk?._onDelete),
       onUpdate: action(fk?.onUpdate, fk?._onUpdate),
@@ -439,7 +544,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
    * on each returned value, so the stand-in results must carry that method or the call throws.
    */
   readRelationsObject(val, exportName, issues) {
-    const from = this.getSymbol(val.table, "drizzle:Name") ?? exportName;
+    const from = qualifiedNameOfDrizzleTable(val.table) ?? exportName;
     const make = (kind) => (table, cfg) => ({
       kind,
       referencedTable: table,
@@ -453,7 +558,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       const built = val.config({ one: make("one"), many: make("many") });
       const out = [];
       for (const rel of Object.values(built ?? {})) {
-        const to = this.getSymbol(rel?.referencedTable, "drizzle:Name");
+        const to = qualifiedNameOfDrizzleTable(rel?.referencedTable);
         if (to) out.push({ kind: rel.kind, from, to });
       }
       return out;
@@ -462,6 +567,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         code: "DRZL_ANL_RELATIONS",
         level: "warn",
         message: `Could not read the relations declared in "${exportName}": ${e.message}`,
+        path: from,
         hint: "Relations for this table will be missing from the analysis."
       });
       return [];
@@ -482,10 +588,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       if (fks.length < 2) continue;
       const fkCols = new Set(fks.flatMap((f) => f.columns));
       if (!t.columns.every((c) => fkCols.has(c.name))) continue;
-      const targets = [...new Set(fks.map((f) => f.foreignTable))];
+      const targets = [...new Set(fks.map(qualifiedForeignTable))];
       if (targets.length !== 2) continue;
-      out.push({ kind: "manyToMany", from: targets[0], to: targets[1], via: t.name });
-      out.push({ kind: "manyToMany", from: targets[1], to: targets[0], via: t.name });
+      const via = qualifiedTableName(t);
+      out.push({ kind: "manyToMany", from: targets[0], to: targets[1], via });
+      out.push({ kind: "manyToMany", from: targets[1], to: targets[0], via });
     }
     return out;
   }
@@ -512,6 +619,24 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       if (inexact) [out.min, out.max] = inexact;
       out.integer = false;
     }
+    const nonFinite = _SchemaAnalyzer.PG_NON_FINITE[ctor];
+    if (nonFinite) {
+      out.allowsNaN = nonFinite.nan;
+      out.allowsInfinity = nonFinite.infinity;
+    }
+    if (DECIMAL_NUMBER_MODE.test(ctor)) {
+      const range2 = decimalModeRange(column, ctor, "number");
+      if (range2) [out.min, out.max] = range2;
+      out.integer = false;
+      if (ctor === "PgNumericNumber") {
+        out.allowsNaN = true;
+        out.allowsInfinity = !declaredDecimalRange(column);
+      }
+    } else if (DECIMAL_BIGINT_MODE.test(ctor)) {
+      const range2 = decimalModeRange(column, ctor, "bigint");
+      if (range2) [out.min, out.max] = range2;
+      out.integer = true;
+    }
     if (/^(Pg)?UUID$/i.test(ctor) || /Uuid$/i.test(ctor)) out.format = "uuid";
     return out;
   }
@@ -523,12 +648,36 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           tsType: column?.config?.mode === "timestamp" ? "Date" : "number",
           dbType: "INTEGER"
         };
+      // Both timestamp modes of `integer()`, which are one class and one type. `timestamp` and
+      // `timestamp_ms` differ in the scale of the number on the wire, seconds against
+      // milliseconds, and `mapFromDriverValue` consumes that difference and hands back a `Date`
+      // either way; nothing downstream of the analyzer ever sees the integer. So an arm keyed on
+      // the class covers both, where the mode check that used to answer this fell through the
+      // switch to a default arm testing `config.mode === 'timestamp'` and named only the first.
+      // The second came back `unknown`, and every generator emitted a schema accepting anything.
+      //
+      // `DATE` rather than the `INTEGER` that mode check returned, so the two majors describe the
+      // column identically. `dbType` is read in exactly one place outside this file,
+      // `isIntegerColumn`, which the generators consult only for a `tsType` of `number`, so the
+      // relabel reaches no output. Measured rather than argued: emitting a `Date` column under
+      // both labels, nullable and not, through all five generators gives ten byte-identical pairs.
+      case "SQLiteTimestamp":
+        return { tsType: "Date", dbType: "DATE" };
       case "SQLiteText":
         return { tsType: "string", dbType: "TEXT" };
       case "SQLiteReal":
         return { tsType: "number", dbType: "REAL" };
+      // No 0.4x column is a `SQLiteBlob`: `sqlite-core` builds a `SQLiteBlobBuffer`, a
+      // `SQLiteBlobJson` or a `SQLiteBigInt`, one per mode, and exports no class of this name at
+      // all. The arm answers the hand-built column in sqlite-types.spec.ts and nothing drizzle
+      // produces, which is why a real `blob()` reached neither it nor anything else.
       case "SQLiteBlob":
         return { tsType: "Uint8Array", dbType: "BLOB" };
+      // The class a real `blob()` and `blob({ mode: 'buffer' })` both build. See `BUFFER_CLASSES`
+      // for the measurement; the answers here are v1's own for the same column, so this is the
+      // two majors agreeing rather than a new opinion.
+      case "SQLiteBlobBuffer":
+        return { tsType: "Buffer", dbType: "BYTEA" };
       // SQLite spells a mode as a distinct class rather than as config, so `text({mode:'json'})`
       // is a `SQLiteTextJson` and matched no arm at all: the column came back UNKNOWN, which is
       // wider than the `any` a json column at least used to get.
@@ -567,6 +716,34 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       case "MySqlEnumColumn":
       case "SingleStoreEnumColumn":
         return { tsType: "string", dbType: "TEXT" };
+      // The pgvector family, found by the analyzer fuzzer: all three came back `unknown` on this
+      // path, so their validators accepted anything. The answers are drizzle's own mappers rather
+      // than the type names, and the three do not agree with each other:
+      //
+      //   vector(3)     SELECT gives [1,2,3]          INSERT sends "[1,2,3]"
+      //   halfvec(3)    SELECT gives [1,2,3]          INSERT sends "[1,2,3]"
+      //   sparsevec(3)  SELECT gives "{1:1.5,3:2}/3"  INSERT sends "{1:1.5,3:2}/3"
+      //
+      // So the two dense ones are number arrays and the sparse one is a string. Typing `sparsevec`
+      // as a vector for symmetry would reject every row the database returns, which is the defect
+      // this family was filed under to begin with. The `shape` carries the dimension count where
+      // one is declared, as the codec path already did for `vector`.
+      case "PgVector":
+      case "PgHalfVector":
+      case "SingleStoreVector":
+        return { tsType: "number[]", dbType: "VECTOR" };
+      // `BIT` rather than `TEXT`, which a first version of this arm returned. v1's codec says `BIT`
+      // for the same column, and the cross-major diff said so: naming the class made ten of its
+      // twelve entries go stale and left `c_bit.dbType` and its nullable twin standing, which is
+      // that check distinguishing a fix from a half fix.
+      case "PgBinaryVector":
+        return { tsType: "string", dbType: "BIT" };
+      case "PgGeometry":
+        return { tsType: "[number, number]", dbType: "GEOMETRY" };
+      case "PgGeometryObject":
+        return { tsType: "{ x: number; y: number }", dbType: "GEOMETRY" };
+      case "PgSparseVector":
+        return { tsType: "string", dbType: "TEXT" };
       case "PgInteger":
       case "PgSmallInt":
         return { tsType: "number", dbType: "INTEGER" };
@@ -727,7 +904,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         if (/^Gel/i.test(ctor)) {
           if (/BigInt64/i.test(ctor)) return { tsType: "bigint", dbType: "BIGINT" };
           if (/Int53|Integer|SmallInt/i.test(ctor)) return { tsType: "number", dbType: "INTEGER" };
-          if (/Real|DoublePrecision/i.test(ctor)) return { tsType: "number", dbType: "NUMERIC" };
+          if (/DoublePrecision/i.test(ctor)) return { tsType: "number", dbType: "DOUBLE" };
+          if (/Real/i.test(ctor)) return { tsType: "number", dbType: "REAL" };
           if (/Decimal/i.test(ctor)) return { tsType: "string", dbType: "NUMERIC" };
           if (/UUID/i.test(ctor)) return { tsType: "string", dbType: "UUID" };
           if (/Json/i.test(ctor)) return { tsType: "any", dbType: "JSON" };
@@ -736,7 +914,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           if (/Bool/i.test(ctor)) return { tsType: "boolean", dbType: "BOOLEAN" };
           if (/TimestampTz/i.test(ctor)) return { tsType: "Date", dbType: "TIMESTAMPTZ" };
           if (/Timestamp|LocalDateString|LocalTime|DateDuration|RelDuration|Duration/i.test(ctor))
-            return { tsType: "unknown", dbType: "UNKNOWN" };
+            return { tsType: "unknown", dbType: "UNKNOWN", unnameable: "gel-temporal" };
         }
         return { tsType: "unknown", dbType: "UNKNOWN" };
     }
@@ -752,7 +930,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     const uniqueGroups = /* @__PURE__ */ new Map();
     for (const [colName, outerCol] of Object.entries(columnsObj)) {
       const { element: col, dimensions: arrayDims } = unwrapArrayColumn(outerCol);
-      let { tsType, dbType } = this.mapColumnType(col);
+      const mapped = this.mapColumnType(col);
+      let { tsType, dbType } = mapped;
       if (tsType === "unknown" && /At$/.test(colName)) {
         tsType = "Date";
         dbType = "INTEGER";
@@ -778,11 +957,13 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       const v1 = describeV1Column(col);
       const constraints = this.columnConstraints(col);
       if (v1?.shape) delete constraints.maxLength;
-      const sqlKind = String(outerCol?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? "");
+      const sqlKind = String(
+        outerCol?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? ""
+      );
       const sqlType = sqlKind.startsWith("MySql") && typeof col?.getSQLType === "function" ? String(col.getSQLType()).toLowerCase() : void 0;
       const byteCap = sqlType ? MYSQL_TEXT_CAPS[sqlType] : void 0;
       const ctorName = String(col?.constructor?.name ?? "");
-      const fallbackShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : BYTE_STRING_CLASSES.has(ctorName) ? { kind: "byteString", length: declaredLength(col) } : GEOMETRIC_CLASS_SHAPES[ctorName];
+      const fallbackShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : BYTE_STRING_CLASSES.has(ctorName) ? { kind: "byteString", length: declaredLength(col) } : BUFFER_CLASSES.has(ctorName) ? { kind: "buffer" } : NUMBER_VECTOR_CLASSES.has(ctorName) ? { kind: "numberVector", length: declaredLength(col) } : BIT_STRING_CLASSES.has(ctorName) ? { kind: "bitstring", length: declaredLength(col), exact: true } : GEOMETRIC_CLASS_SHAPES[ctorName];
       if (fallbackShape?.kind === "byteString") delete constraints.maxLength;
       const shape = (v1?.shape ?? fallbackShape)?.kind;
       const finalTs = v1?.tsType ?? tsType;
@@ -793,13 +974,26 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           code: "DRZL_ANL_UNKNOWN_COLUMN",
           level: "warn",
           message: `Column "${colName}" on table "${tsName}" has no known type${sqlType2 ? ` (SQL type ${sqlType2})` : ""}, so its validator will accept any value.`,
-          hint: shape === "custom" ? "A customType has no runtime shape to read. Declare it with .$type<T>() and turn on typedColumns to give the validator the type." : "Open an issue naming the column type so it can be modelled, or declare it with .$type<T>() and turn on typedColumns."
+          path: `${tsName}.${colName}`,
+          hint: unknownColumnHint(shape === "custom" ? "custom" : mapped.unnameable)
         });
       }
+      const dims = arrayDims || v1?.arrayDimensions || 0;
+      const declaredSqlType = (() => {
+        let raw;
+        try {
+          raw = typeof outerCol?.getSQLType === "function" ? outerCol.getSQLType() : void 0;
+        } catch {
+          return void 0;
+        }
+        if (typeof raw !== "string" || !raw) return void 0;
+        return raw.endsWith("]") ? raw : raw + "[]".repeat(dims);
+      })();
       columns.push({
         name: colName,
         tsType,
         dbType,
+        ...declaredSqlType ? { sqlType: declaredSqlType } : {},
         nullable,
         hasDefault,
         isGenerated,
@@ -876,6 +1070,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       if (!col) continue;
       col.references = {
         table: fk.foreignTable,
+        ...fk.foreignSchema ? { schema: fk.foreignSchema } : {},
         column: fk.foreignColumns[0],
         onDelete: fk.onDelete,
         onUpdate: fk.onUpdate
@@ -948,9 +1143,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
             }
           }
           if (opts.includeRelations) {
+            const self = qualifiedTableName(table);
             for (const fk of table.foreignKeys ?? []) {
-              relations.push({ kind: "one", from: table.name, to: fk.foreignTable });
-              relations.push({ kind: "many", from: fk.foreignTable, to: table.name });
+              const target = qualifiedForeignTable(fk);
+              relations.push({ kind: "one", from: self, to: target });
+              relations.push({ kind: "many", from: target, to: self });
             }
           }
         } else if (this.isRelationsObject(val)) {
@@ -978,7 +1175,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         issues.push({
           code: "DRZL_ANL_TABLE",
           level: "warn",
-          message: `Failed to analyze export ${name}: ${String(e)}`
+          message: `Failed to analyze export ${name}: ${String(e)}`,
+          path: name
         });
       }
     }
@@ -1023,11 +1221,21 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       relations.push(...this.inferManyToMany(tables));
     }
     if (opts.includeRelations && opts.includeHeuristicRelations) {
-      const tableNames = new Set(tables.map((t) => t.name));
-      const findTarget = (base) => {
-        if (tableNames.has(base)) return base;
-        if (tableNames.has(base + "s")) return base + "s";
-        if (tableNames.has(base + "es")) return base + "es";
+      const byBareName = /* @__PURE__ */ new Map();
+      for (const t of tables) {
+        const list = byBareName.get(t.name);
+        if (list) list.push(t);
+        else byBareName.set(t.name, [t]);
+      }
+      const findTarget = (base, from) => {
+        for (const candidate of [base, base + "s", base + "es"]) {
+          const hits = byBareName.get(candidate);
+          if (!hits?.length) continue;
+          const sameSchema = hits.filter((t) => t.schema === from.schema);
+          if (sameSchema.length === 1) return qualifiedTableName(sameSchema[0]);
+          if (hits.length === 1) return qualifiedTableName(hits[0]);
+          return void 0;
+        }
         return void 0;
       };
       for (const t of tables) {
@@ -1035,8 +1243,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           if (c.references) continue;
           if (c.name.endsWith("Id")) {
             const base = c.name.slice(0, -2);
-            const target = findTarget(base);
-            if (target) relations.push({ kind: "one", from: t.name, to: target });
+            const target = findTarget(base, t);
+            if (target) relations.push({ kind: "one", from: qualifiedTableName(t), to: target });
           }
         }
       }
@@ -1145,10 +1353,58 @@ _SchemaAnalyzer.INEXACT_RANGES = {
   SQLiteReal: null,
   SingleStoreDouble: null,
   SingleStoreReal: null,
-  // `numeric({ mode: 'number' })`, which v1 reaches through the bare-number arm of
-  // `describeV1Column`. This one is about what a JS number can carry rather than about the
-  // column, which Postgres caps far lower: it refuses 2147483648 into a `numeric(10,2)`.
-  PgNumericNumber: JS_SAFE_INTEGER_BOUNDS
+  // Gel, whose `real` is a `std::float32` and whose `doublePrecision` is a `std::float64`. Both
+  // used to be answered by a `/Real|DoublePrecision/i` arm that said NUMERIC and stated nothing
+  // else at all, so a `real` column accepted 1e300 and the server refused it.
+  //
+  // Measured on a live Gel 7.1 (`geldata/gel:7`, sys::get_version_as_str() -> 7.1+08db576)
+  // through the `gel` client, casting each literal so the server parses it, and again through a
+  // stored property on a real object type. The float32 edge is Postgres's exactly, to the double:
+  //
+  //   3.4028234663852886e38   accepted, returned unchanged
+  //   3.4028235677973366e38   accepted, and stored as 3.4028234663852886e38
+  //   3.402823567797337e38    refused, "is out of range for type std::float32"
+  //   1e300                   refused, the same way
+  //
+  // The same value accepted, the same next double up refused, and the same rounding down of the
+  // midpoint, so it takes the constant already here rather than a second name for one number.
+  // float64 took 1e300 and Number.MAX_VALUE faithfully, for the reason no 8 byte float has a
+  // truthful finite bound.
+  GelReal: PG_FLOAT4_RANGE,
+  GelDoublePrecision: null
+};
+// `numeric`/`decimal` in either of its two numeric modes is deliberately not in the table above.
+// Its bound is not a fixed magnitude per class but the precision each column declares for itself,
+// which no table keyed on a class name can hold; see `declaredDecimalRange`.
+/**
+ * The Postgres number columns that hold a non-finite double, and which of the three each holds.
+ *
+ * The class-name half of what `describeV1Column` reads off the codec, and the two must agree: a
+ * fact stated on one path and not the other is a schema that changes when the user upgrades
+ * drizzle, which the cross-major diff in `verify-packed.sh` fails on. These three class names are
+ * the same on both majors, read off real `pgTable` columns on 0.45.2 and on 1.0.0-rc.4, so this
+ * table also answers for a v1 column and the two answers are identical rather than merely
+ * compatible. non-finite-numbers.spec.ts asserts that agreement through the real analyzer.
+ *
+ * No MySQL, SingleStore or SQLite class belongs here: MySQL refuses all three on a `float`/
+ * `double` and stores `0.00` for a `decimal`, and SQLite returns both infinities while silently
+ * turning `NaN` into NULL, which is a different answer that has to arrive whole.
+ *
+ * Gel does belong, and is the fourth and fifth entries. Measured on a live Gel 7.1 rather than
+ * inferred from it being Postgres-backed: both `std::float32` and `std::float64` stored `nan`,
+ * `inf` and `-inf` and handed all three back as `NaN`, `Infinity` and `-Infinity`, through a cast
+ * and again through a stored property. Without them every row of such a column failed validation.
+ *
+ * `PgNumeric` is absent because its value is a string, and its pattern already accepts `NaN` and
+ * `Infinity`. `PgNumericNumber` is absent because its answer is no longer flat: it takes `NaN` at
+ * any width and an infinity only where no precision is declared, which is a per-column question
+ * this table cannot ask. `columnConstraints` answers it beside the bound that decides it.
+ */
+_SchemaAnalyzer.PG_NON_FINITE = {
+  PgReal: { nan: true, infinity: true },
+  PgDoublePrecision: { nan: true, infinity: true },
+  GelReal: { nan: true, infinity: true },
+  GelDoublePrecision: { nan: true, infinity: true }
 };
 var SchemaAnalyzer = _SchemaAnalyzer;
 var index_default = SchemaAnalyzer;
@@ -1159,5 +1415,7 @@ export {
   isDrizzleView,
   isReadOnlyRelation,
   isRelationsV2,
+  qualifiedForeignTable,
+  qualifiedTableName,
   readRelationsV2
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/analyzer",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -28,6 +28,7 @@
   },
   "devDependencies": {
     "drizzle-orm": "^0.45.2",
+    "drizzle-orm-v1": "npm:drizzle-orm@1.0.0-rc.4",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
@@ -51,6 +52,8 @@
   "scripts": {
     "build": "tsup src/index.ts --dts --format esm,cjs --clean",
     "lint": "eslint . --ext .ts",
-    "test": "vitest run --testTimeout=20000"
+    "test": "vitest run --testTimeout=20000",
+    "fuzz": "node test/fuzz/run.mjs",
+    "fuzz:gate": "node test/fuzz/run.mjs --gate"
   }
 }