@drzl/analyzer 1.14.0 → 1.16.0

package/README.md

@@ -47,6 +47,17 @@ The CLI consumes this analysis to generate validation, services, and routers.
 - relations (incl. inferred), enums
 - issues (warnings/errors) for constraints and shape
 
+Per column, beyond the type: `nullable`, `hasDefault`, `defaultValue` (literal defaults only),
+`isGenerated`, `enumValues`, `maxLength` (characters), `maxBytes` (MySQL's TEXT family is a byte
+budget, which is a different measurement on the same kind of column), `min`/`max`,
+`arrayDimensions`, `format`, and `shape` for values that are not scalars (json, buffer, tuple,
+vector, bitstring, customType).
+
+`DRZL_ANL_UNKNOWN_COLUMN` is reported for any column whose validator would accept anything, which
+is the shape a missing type mapping takes: nothing throws, and every row passes.
+
 ## Notes
 
-- Best‑effort introspection aligned with Drizzle symbols across versions.
+- Best‑effort introspection aligned with Drizzle symbols across versions. Both live majors are
+  covered and diffed against each other in CI: 0.4x and v1 model arrays and enums differently, and
+  reading only one silently typed every `.array()` column as `unknown` on the other.

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   SchemaAnalyzer: () => SchemaAnalyzer,
   default: () => index_default,
   describeV1Column: () => describeV1Column,
+  isDrizzleView: () => isDrizzleView,
   isReadOnlyRelation: () => isReadOnlyRelation,
   isRelationsV2: () => isRelationsV2,
   readRelationsV2: () => readRelationsV2
@@ -57,12 +58,18 @@ var MYSQL_TEXT_CAPS = {
   mediumblob: 16777215,
   longblob: 4294967295
 };
-var V1_FLOAT_BOUNDS = {
-  float: ["-8388608", "8388607"],
-  // real / float4, 2^23
-  double: ["-140737488355328", "140737488355327"]
-  // double precision / float8, 2^47
+var FLOAT32_MAX = "340282346638528859811704183484516925440";
+var PG_FLOAT4_INPUT_MAX = "340282356779733661637539395458142568448";
+var PG_FLOAT4_RANGE = [`-${PG_FLOAT4_INPUT_MAX}`, PG_FLOAT4_INPUT_MAX];
+var MYSQL_FLOAT_RANGE = [`-${FLOAT32_MAX}`, FLOAT32_MAX];
+var JS_SAFE_INTEGER_BOUNDS = ["-9007199254740991", "9007199254740991"];
+var TUPLE_CLASS_SHAPES = {
+  // `line()` is the trap here: its `drizzle:entityKind` is `PgLine` while its constructor is
+  // `PgLineTuple`, and this path matches on the constructor.
+  PgPointTuple: { kind: "tuple", length: 2 },
+  PgLineTuple: { kind: "tuple", length: 3 }
 };
+var V1_ONLY_ENTITY_KINDS = /^(?:MsSql|Cockroach)/;
 function describeV1Column(column) {
   const codec = column?.codec;
   const dataType = column?.dataType;
@@ -75,8 +82,9 @@ function describeV1Column(column) {
       shape: { kind: "custom", sqlType: typeof sqlType === "string" ? sqlType : void 0 }
     };
   }
+  const entityKind = String(column?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? "");
   const [js, semantic = ""] = dataType.split(" ");
-  if (typeof codec !== "string" && !semantic) return null;
+  if (typeof codec !== "string" && !semantic && !V1_ONLY_ENTITY_KINDS.test(entityKind)) return null;
   const out = {};
   switch (semantic) {
     case "int8":
@@ -111,7 +119,8 @@ function describeV1Column(column) {
       break;
     case "float":
     case "double": {
-      [out.min, out.max] = V1_FLOAT_BOUNDS[semantic];
+      if (semantic === "float")
+        [out.min, out.max] = codec === "float4" || entityKind.startsWith("Cockroach") ? PG_FLOAT4_RANGE : MYSQL_FLOAT_RANGE;
       out.integer = false;
       out.tsType = "number";
       out.dbType = semantic === "float" ? "REAL" : "DOUBLE";
@@ -200,7 +209,7 @@ function describeV1Column(column) {
         out.tsType = "number";
         out.dbType = "NUMERIC";
         out.integer = false;
-        [out.min, out.max] = ["-9007199254740991", "9007199254740991"];
+        [out.min, out.max] = JS_SAFE_INTEGER_BOUNDS;
       } else if (js === "string") {
         out.tsType = "string";
         out.dbType = codec === "varchar" ? "VARCHAR" : codec === "char" ? "CHAR" : "TEXT";
@@ -228,15 +237,33 @@ 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 getSymbolOf(target, key) {
-  if (!target) return void 0;
+var VIEW_CONFIG_FIELDS = {
+  "drizzle:Columns": "selectedFields",
+  "drizzle:Name": "name",
+  "drizzle:Schema": "schema"
+};
+function ownSymbolOf(target, key) {
   try {
     for (const sym of Object.getOwnPropertySymbols(target)) {
       if (sym.description === key) return target[sym];
     }
   } catch {
   }
-  return target[Symbol.for(key)];
+  return void 0;
+}
+function getSymbolOf(target, key) {
+  if (!target) return void 0;
+  const own = ownSymbolOf(target, key);
+  if (own !== void 0) return own;
+  const direct = target[Symbol.for(key)];
+  if (direct !== void 0) return direct;
+  const field = VIEW_CONFIG_FIELDS[key];
+  if (!field) return void 0;
+  const cfg = ownSymbolOf(target, "drizzle:ViewBaseConfig");
+  return cfg ? cfg[field] : void 0;
+}
+function isDrizzleView(val) {
+  return !!val && typeof val === "object" && !!getSymbolOf(val, "drizzle:ViewBaseConfig");
 }
 function isReadOnlyRelation(val) {
   if (!val || typeof val !== "object") return false;
@@ -280,17 +307,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     this.schemaPath = schemaPath;
   }
   getSymbol(table, key) {
-    if (!table) return void 0;
-    try {
-      const syms = Object.getOwnPropertySymbols(table);
-      for (const s of syms) {
-        if (s.description === key) {
-          return table[s];
-        }
-      }
-    } catch {
-    }
-    return table[Symbol.for(key)];
+    return getSymbolOf(table, key);
   }
   /**
    * Drizzle keys the Columns object by TypeScript property name, but every other piece of
@@ -507,6 +524,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       [out.min, out.max] = range;
       out.integer = true;
     }
+    if (Object.prototype.hasOwnProperty.call(_SchemaAnalyzer.INEXACT_RANGES, ctor)) {
+      const inexact = _SchemaAnalyzer.INEXACT_RANGES[ctor];
+      if (inexact) [out.min, out.max] = inexact;
+      out.integer = false;
+    }
     if (/^(Pg)?UUID$/i.test(ctor) || /Uuid$/i.test(ctor)) out.format = "uuid";
     return out;
   }
@@ -578,9 +600,25 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         return { tsType: "Date", dbType: "TIMESTAMP" };
       case "PgNumeric":
         return { tsType: "string", dbType: "NUMERIC" };
-      case "PgFloat":
       case "PgDoublePrecision":
         return { tsType: "number", dbType: "DOUBLE" };
+      // `real()` builds a `PgReal`, which matched no arm and fell through to the coarse
+      // `/Numeric|Float|Double|Real/i` below, so a real column was labelled NUMERIC while v1
+      // called it REAL. The arm above used to name `PgFloat` alongside `PgDoublePrecision`, and
+      // no such class exists in pg-core on either major: `float` is MySQL's spelling and Gel's
+      // is `GelReal`, both of which are matched elsewhere. Enumerated from the module's own
+      // exports on 0.45.2 and on 1.0.0-rc.4, which name only PgReal and PgDoublePrecision.
+      case "PgReal":
+        return { tsType: "number", dbType: "REAL" };
+      // 0.4x names a point and a line by their mode. `point()` is a `PgPointTuple` and `line()` a
+      // `PgLineTuple`, whose entity kind is `PgLine` while its constructor is not, and both used
+      // to fall through to `/Point|Line/i` and come back `string`. The driver hands back [x, y]
+      // and [a, b, c], so a select schema built on 0.4x refused every row, and an insert schema
+      // took the one string form `mapToDriverValue` turns into something Postgres rejects.
+      case "PgPointTuple":
+        return { tsType: "[number, number]", dbType: "POINT" };
+      case "PgLineTuple":
+        return { tsType: "[number, number, number]", dbType: "LINE" };
       case "PgJson":
       case "PgJsonb":
         return { tsType: "any", dbType: ctor === "PgJsonb" ? "JSONB" : "JSON" };
@@ -654,11 +692,10 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           if (/Json/i.test(ctor)) return { tsType: "any", dbType: "JSON" };
           if (/Text/i.test(ctor)) return { tsType: "string", dbType: "TEXT" };
           if (/Bytes/i.test(ctor)) return { tsType: "Uint8Array", dbType: "BLOB" };
+          if (/Bool/i.test(ctor)) return { tsType: "boolean", dbType: "BOOLEAN" };
           if (/TimestampTz/i.test(ctor)) return { tsType: "Date", dbType: "TIMESTAMPTZ" };
-          if (/Timestamp/i.test(ctor)) return { tsType: "string", dbType: "TIMESTAMP" };
-          if (/LocalDateString|LocalTime/i.test(ctor)) return { tsType: "string", dbType: "TEXT" };
-          if (/DateDuration|RelDuration|Duration/i.test(ctor))
-            return { tsType: "string", dbType: "TEXT" };
+          if (/Timestamp|LocalDateString|LocalTime|DateDuration|RelDuration|Duration/i.test(ctor))
+            return { tsType: "unknown", dbType: "UNKNOWN" };
         }
         return { tsType: "unknown", dbType: "UNKNOWN" };
     }
@@ -703,8 +740,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       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 jsonShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : void 0;
-      const shape = (v1?.shape ?? jsonShape)?.kind;
+      const fallbackShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : TUPLE_CLASS_SHAPES[String(col?.constructor?.name ?? "")];
+      const shape = (v1?.shape ?? fallbackShape)?.kind;
       const finalTs = v1?.tsType ?? tsType;
       const wide = (finalTs === "unknown" || finalTs === "any") && (!shape || shape === "custom");
       if (wide) {
@@ -733,7 +770,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         // that spread has nothing to say and this is the only source.
         ...arrayDims ? { arrayDimensions: arrayDims } : {},
         // Only where v1 did not already describe the value, so a shaped column keeps its shape.
-        ...jsonShape && !v1?.shape ? { shape: jsonShape } : {},
+        ...fallbackShape && !v1?.shape ? { shape: fallbackShape } : {},
         ...byteCap && v1?.maxBytes === void 0 ? { maxBytes: byteCap } : {}
       });
     }
@@ -853,12 +890,14 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     const relations = [];
     const enums = [];
     const columnEnums = [];
+    const viewTables = [];
     for (const [name, val] of Object.entries(exportsObj)) {
       try {
         const cols = this.getSymbol(val, "drizzle:Columns");
         if (cols && typeof cols === "object") {
           const table = this.analyzeTable(name, val, issues);
           tables.push(table);
+          if (isDrizzleView(val)) viewTables.push(table);
           for (const col of table.columns) {
             const enumVals = cols[col.name]?.enumValues;
             if (enumVals && enumVals.length) {
@@ -909,7 +948,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     let dialect = "unknown";
     const marks = /* @__PURE__ */ new Set();
     for (const [_, val] of Object.entries(exportsObj)) {
-      const cols = val?.[/* @__PURE__ */ Symbol.for("drizzle:Columns")];
+      const cols = this.getSymbol(val, "drizzle:Columns");
       if (!cols) continue;
       for (const c of Object.values(cols)) {
         const kind = c?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")];
@@ -926,6 +965,9 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     else if (/MySql|Mysql/i.test(names)) dialect = "mysql";
     else if (/Pg|Postgres/i.test(names)) dialect = "postgres";
     else if (/Gel/i.test(names)) dialect = "gel";
+    if (dialect === "sqlite") {
+      for (const view of viewTables) view.readOnly = true;
+    }
     if (dialect === "unknown" && tables.length) {
       issues.push({
         code: "DRZL_ANL_DIALECT",
@@ -1011,12 +1053,67 @@ _SchemaAnalyzer.INT_RANGES = {
   MySqlBigInt64: ["-9223372036854775808", "9223372036854775807"],
   SingleStoreBigInt64: ["-9223372036854775808", "9223372036854775807"]
 };
+/**
+ * The numeric column classes that are not exact, and the magnitude each one can really hold.
+ *
+ * Only drizzle v1 states this outright, as a `float` or `double` semantic on `dataType`. On
+ * 0.4x the same columns reach the analyzer by class name, `INT_RANGES` was the only range table
+ * on that path, and so nothing said anything about them at all: not the range, and not that
+ * they are inexact. The parity gate measured seven of the ten classes below and reported DRZL
+ * differing from the first-party validator for the same major on all seven. The three
+ * SingleStore classes are in no fixture either pass carries and are covered by unit tests alone.
+ *
+ * Differing is what the gate reports, not what it forbids. Most of its waivers have DRZL
+ * accepting something official refuses and the run counts them; an earlier version of this
+ * sentence said the gate exists to forbid being looser, which the same commit's own success
+ * banner denies.
+ *
+ * `null` is a value in this table and is not the same as a class it does not name. It says the
+ * column is inexact and that no finite magnitude bound is truthful for it, which is the case for
+ * every 8 byte float: float8 is the JavaScript number's own format, so Postgres accepts every
+ * finite JS number into one, measured to `Number.MAX_VALUE`. Read with an own-property test for
+ * that reason, and because a plain object answers to `constructor` and `toString`.
+ *
+ * `integer: false` travels with every entry, bound or not, and what it decides depends on which.
+ * `isIntegerColumn` falls back to "declares both bounds" when the flag is absent, so on a bounded
+ * entry the flag is the only thing stopping the emitted schema calling `.int()` and refusing 1.5.
+ * On an unbounded one it decides nothing, measured both ways against the real function in
+ * `@drzl/validation-core`'s integer-column.spec.ts. It is stated there because it is true of the
+ * column, not because it guards anything. That spec is where the measurement moved when the
+ * analyzer's copy of it turned out to be a closed loop; this sentence went on naming
+ * floats-and-tuples-0.4x.spec.ts, which asserts the flag is present and nothing about what it
+ * decides.
+ *
+ * The widths are the type's, not the name's: MySQL and SingleStore `real` is a synonym for
+ * `double` unless REAL_AS_FLOAT is set, and SQLite `real` is an 8 byte IEEE float. Both are
+ * `number double` on drizzle v1, which is where these pairings come from.
+ */
+_SchemaAnalyzer.INEXACT_RANGES = {
+  // 4 byte floats, the one width a database refuses a magnitude for, and the two that have one
+  // refuse at different values. SingleStore is MySQL wire-compatible and unmeasured here, so it
+  // takes MySQL's rather than the wider of the two.
+  PgReal: PG_FLOAT4_RANGE,
+  MySqlFloat: MYSQL_FLOAT_RANGE,
+  SingleStoreFloat: MYSQL_FLOAT_RANGE,
+  // 8 byte floats, which hold every finite JS number
+  PgDoublePrecision: null,
+  MySqlDouble: null,
+  MySqlReal: null,
+  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
+};
 var SchemaAnalyzer = _SchemaAnalyzer;
 var index_default = SchemaAnalyzer;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SchemaAnalyzer,
   describeV1Column,
+  isDrizzleView,
   isReadOnlyRelation,
   isRelationsV2,
   readRelationsV2

package/dist/index.d.cts

@@ -231,6 +231,17 @@ interface AnalyzeOptions {
  * path below untouched.
  */
 declare function describeV1Column(column: any): Partial<Column> | null;
+/**
+ * Whether an export is a Drizzle view, of any dialect and on either major.
+ *
+ * Asked of `drizzle:ViewBaseConfig` rather than of `drizzle:IsDrizzleView`, which reads like the
+ * obvious question and is not there to be asked: the marker was introduced in 0.39.0, and a view
+ * built on 0.29.5, 0.33.0 or 0.36.4 answers undefined to it. The config is an own symbol on all
+ * eleven releases probed and on every view form measured, on both majors: the query-builder and
+ * explicit-column-list forms of pg view, pg materialized view, mysql view and sqlite view,
+ * `.existing()`, and the schema-qualified pg view and materialized view.
+ */
+declare function isDrizzleView(val: any): boolean;
 /**
  * Whether an export is a Relations v2 definition, from `defineRelations(schema, (r) => ...)`.
  *
@@ -354,6 +365,42 @@ declare class SchemaAnalyzer {
      * promise a precision that cannot survive the round trip.
      */
     private static readonly INT_RANGES;
+    /**
+     * The numeric column classes that are not exact, and the magnitude each one can really hold.
+     *
+     * Only drizzle v1 states this outright, as a `float` or `double` semantic on `dataType`. On
+     * 0.4x the same columns reach the analyzer by class name, `INT_RANGES` was the only range table
+     * on that path, and so nothing said anything about them at all: not the range, and not that
+     * they are inexact. The parity gate measured seven of the ten classes below and reported DRZL
+     * differing from the first-party validator for the same major on all seven. The three
+     * SingleStore classes are in no fixture either pass carries and are covered by unit tests alone.
+     *
+     * Differing is what the gate reports, not what it forbids. Most of its waivers have DRZL
+     * accepting something official refuses and the run counts them; an earlier version of this
+     * sentence said the gate exists to forbid being looser, which the same commit's own success
+     * banner denies.
+     *
+     * `null` is a value in this table and is not the same as a class it does not name. It says the
+     * column is inexact and that no finite magnitude bound is truthful for it, which is the case for
+     * every 8 byte float: float8 is the JavaScript number's own format, so Postgres accepts every
+     * finite JS number into one, measured to `Number.MAX_VALUE`. Read with an own-property test for
+     * that reason, and because a plain object answers to `constructor` and `toString`.
+     *
+     * `integer: false` travels with every entry, bound or not, and what it decides depends on which.
+     * `isIntegerColumn` falls back to "declares both bounds" when the flag is absent, so on a bounded
+     * entry the flag is the only thing stopping the emitted schema calling `.int()` and refusing 1.5.
+     * On an unbounded one it decides nothing, measured both ways against the real function in
+     * `@drzl/validation-core`'s integer-column.spec.ts. It is stated there because it is true of the
+     * column, not because it guards anything. That spec is where the measurement moved when the
+     * analyzer's copy of it turned out to be a closed loop; this sentence went on naming
+     * floats-and-tuples-0.4x.spec.ts, which asserts the flag is present and nothing about what it
+     * decides.
+     *
+     * The widths are the type's, not the name's: MySQL and SingleStore `real` is a synonym for
+     * `double` unless REAL_AS_FLOAT is set, and SQLite `real` is an 8 byte IEEE float. Both are
+     * `number double` on drizzle v1, which is where these pairings come from.
+     */
+    private static readonly INEXACT_RANGES;
     /**
      * Constraints the column definition already carries, which the analysis used to throw away.
      *
@@ -366,4 +413,4 @@ declare class SchemaAnalyzer {
     analyze(opts?: AnalyzeOptions): Promise<Analysis>;
 }
 
-export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type ColumnShape, type Dialect, type Enum, type ForeignKey, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default, describeV1Column, isReadOnlyRelation, isRelationsV2, readRelationsV2 };
+export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type ColumnShape, type Dialect, type Enum, type ForeignKey, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default, describeV1Column, isDrizzleView, isReadOnlyRelation, isRelationsV2, readRelationsV2 };

package/dist/index.d.ts

@@ -231,6 +231,17 @@ interface AnalyzeOptions {
  * path below untouched.
  */
 declare function describeV1Column(column: any): Partial<Column> | null;
+/**
+ * Whether an export is a Drizzle view, of any dialect and on either major.
+ *
+ * Asked of `drizzle:ViewBaseConfig` rather than of `drizzle:IsDrizzleView`, which reads like the
+ * obvious question and is not there to be asked: the marker was introduced in 0.39.0, and a view
+ * built on 0.29.5, 0.33.0 or 0.36.4 answers undefined to it. The config is an own symbol on all
+ * eleven releases probed and on every view form measured, on both majors: the query-builder and
+ * explicit-column-list forms of pg view, pg materialized view, mysql view and sqlite view,
+ * `.existing()`, and the schema-qualified pg view and materialized view.
+ */
+declare function isDrizzleView(val: any): boolean;
 /**
  * Whether an export is a Relations v2 definition, from `defineRelations(schema, (r) => ...)`.
  *
@@ -354,6 +365,42 @@ declare class SchemaAnalyzer {
      * promise a precision that cannot survive the round trip.
      */
     private static readonly INT_RANGES;
+    /**
+     * The numeric column classes that are not exact, and the magnitude each one can really hold.
+     *
+     * Only drizzle v1 states this outright, as a `float` or `double` semantic on `dataType`. On
+     * 0.4x the same columns reach the analyzer by class name, `INT_RANGES` was the only range table
+     * on that path, and so nothing said anything about them at all: not the range, and not that
+     * they are inexact. The parity gate measured seven of the ten classes below and reported DRZL
+     * differing from the first-party validator for the same major on all seven. The three
+     * SingleStore classes are in no fixture either pass carries and are covered by unit tests alone.
+     *
+     * Differing is what the gate reports, not what it forbids. Most of its waivers have DRZL
+     * accepting something official refuses and the run counts them; an earlier version of this
+     * sentence said the gate exists to forbid being looser, which the same commit's own success
+     * banner denies.
+     *
+     * `null` is a value in this table and is not the same as a class it does not name. It says the
+     * column is inexact and that no finite magnitude bound is truthful for it, which is the case for
+     * every 8 byte float: float8 is the JavaScript number's own format, so Postgres accepts every
+     * finite JS number into one, measured to `Number.MAX_VALUE`. Read with an own-property test for
+     * that reason, and because a plain object answers to `constructor` and `toString`.
+     *
+     * `integer: false` travels with every entry, bound or not, and what it decides depends on which.
+     * `isIntegerColumn` falls back to "declares both bounds" when the flag is absent, so on a bounded
+     * entry the flag is the only thing stopping the emitted schema calling `.int()` and refusing 1.5.
+     * On an unbounded one it decides nothing, measured both ways against the real function in
+     * `@drzl/validation-core`'s integer-column.spec.ts. It is stated there because it is true of the
+     * column, not because it guards anything. That spec is where the measurement moved when the
+     * analyzer's copy of it turned out to be a closed loop; this sentence went on naming
+     * floats-and-tuples-0.4x.spec.ts, which asserts the flag is present and nothing about what it
+     * decides.
+     *
+     * The widths are the type's, not the name's: MySQL and SingleStore `real` is a synonym for
+     * `double` unless REAL_AS_FLOAT is set, and SQLite `real` is an 8 byte IEEE float. Both are
+     * `number double` on drizzle v1, which is where these pairings come from.
+     */
+    private static readonly INEXACT_RANGES;
     /**
      * Constraints the column definition already carries, which the analysis used to throw away.
      *
@@ -366,4 +413,4 @@ declare class SchemaAnalyzer {
     analyze(opts?: AnalyzeOptions): Promise<Analysis>;
 }
 
-export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type ColumnShape, type Dialect, type Enum, type ForeignKey, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default, describeV1Column, isReadOnlyRelation, isRelationsV2, readRelationsV2 };
+export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type ColumnShape, type Dialect, type Enum, type ForeignKey, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default, describeV1Column, isDrizzleView, isReadOnlyRelation, isRelationsV2, readRelationsV2 };

package/dist/index.js

@@ -17,12 +17,18 @@ var MYSQL_TEXT_CAPS = {
   mediumblob: 16777215,
   longblob: 4294967295
 };
-var V1_FLOAT_BOUNDS = {
-  float: ["-8388608", "8388607"],
-  // real / float4, 2^23
-  double: ["-140737488355328", "140737488355327"]
-  // double precision / float8, 2^47
+var FLOAT32_MAX = "340282346638528859811704183484516925440";
+var PG_FLOAT4_INPUT_MAX = "340282356779733661637539395458142568448";
+var PG_FLOAT4_RANGE = [`-${PG_FLOAT4_INPUT_MAX}`, PG_FLOAT4_INPUT_MAX];
+var MYSQL_FLOAT_RANGE = [`-${FLOAT32_MAX}`, FLOAT32_MAX];
+var JS_SAFE_INTEGER_BOUNDS = ["-9007199254740991", "9007199254740991"];
+var TUPLE_CLASS_SHAPES = {
+  // `line()` is the trap here: its `drizzle:entityKind` is `PgLine` while its constructor is
+  // `PgLineTuple`, and this path matches on the constructor.
+  PgPointTuple: { kind: "tuple", length: 2 },
+  PgLineTuple: { kind: "tuple", length: 3 }
 };
+var V1_ONLY_ENTITY_KINDS = /^(?:MsSql|Cockroach)/;
 function describeV1Column(column) {
   const codec = column?.codec;
   const dataType = column?.dataType;
@@ -35,8 +41,9 @@ function describeV1Column(column) {
       shape: { kind: "custom", sqlType: typeof sqlType === "string" ? sqlType : void 0 }
     };
   }
+  const entityKind = String(column?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? "");
   const [js, semantic = ""] = dataType.split(" ");
-  if (typeof codec !== "string" && !semantic) return null;
+  if (typeof codec !== "string" && !semantic && !V1_ONLY_ENTITY_KINDS.test(entityKind)) return null;
   const out = {};
   switch (semantic) {
     case "int8":
@@ -71,7 +78,8 @@ function describeV1Column(column) {
       break;
     case "float":
     case "double": {
-      [out.min, out.max] = V1_FLOAT_BOUNDS[semantic];
+      if (semantic === "float")
+        [out.min, out.max] = codec === "float4" || entityKind.startsWith("Cockroach") ? PG_FLOAT4_RANGE : MYSQL_FLOAT_RANGE;
       out.integer = false;
       out.tsType = "number";
       out.dbType = semantic === "float" ? "REAL" : "DOUBLE";
@@ -160,7 +168,7 @@ function describeV1Column(column) {
         out.tsType = "number";
         out.dbType = "NUMERIC";
         out.integer = false;
-        [out.min, out.max] = ["-9007199254740991", "9007199254740991"];
+        [out.min, out.max] = JS_SAFE_INTEGER_BOUNDS;
       } else if (js === "string") {
         out.tsType = "string";
         out.dbType = codec === "varchar" ? "VARCHAR" : codec === "char" ? "CHAR" : "TEXT";
@@ -188,15 +196,33 @@ 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 getSymbolOf(target, key) {
-  if (!target) return void 0;
+var VIEW_CONFIG_FIELDS = {
+  "drizzle:Columns": "selectedFields",
+  "drizzle:Name": "name",
+  "drizzle:Schema": "schema"
+};
+function ownSymbolOf(target, key) {
   try {
     for (const sym of Object.getOwnPropertySymbols(target)) {
       if (sym.description === key) return target[sym];
     }
   } catch {
   }
-  return target[Symbol.for(key)];
+  return void 0;
+}
+function getSymbolOf(target, key) {
+  if (!target) return void 0;
+  const own = ownSymbolOf(target, key);
+  if (own !== void 0) return own;
+  const direct = target[Symbol.for(key)];
+  if (direct !== void 0) return direct;
+  const field = VIEW_CONFIG_FIELDS[key];
+  if (!field) return void 0;
+  const cfg = ownSymbolOf(target, "drizzle:ViewBaseConfig");
+  return cfg ? cfg[field] : void 0;
+}
+function isDrizzleView(val) {
+  return !!val && typeof val === "object" && !!getSymbolOf(val, "drizzle:ViewBaseConfig");
 }
 function isReadOnlyRelation(val) {
   if (!val || typeof val !== "object") return false;
@@ -240,17 +266,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     this.schemaPath = schemaPath;
   }
   getSymbol(table, key) {
-    if (!table) return void 0;
-    try {
-      const syms = Object.getOwnPropertySymbols(table);
-      for (const s of syms) {
-        if (s.description === key) {
-          return table[s];
-        }
-      }
-    } catch {
-    }
-    return table[Symbol.for(key)];
+    return getSymbolOf(table, key);
   }
   /**
    * Drizzle keys the Columns object by TypeScript property name, but every other piece of
@@ -467,6 +483,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       [out.min, out.max] = range;
       out.integer = true;
     }
+    if (Object.prototype.hasOwnProperty.call(_SchemaAnalyzer.INEXACT_RANGES, ctor)) {
+      const inexact = _SchemaAnalyzer.INEXACT_RANGES[ctor];
+      if (inexact) [out.min, out.max] = inexact;
+      out.integer = false;
+    }
     if (/^(Pg)?UUID$/i.test(ctor) || /Uuid$/i.test(ctor)) out.format = "uuid";
     return out;
   }
@@ -538,9 +559,25 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         return { tsType: "Date", dbType: "TIMESTAMP" };
       case "PgNumeric":
         return { tsType: "string", dbType: "NUMERIC" };
-      case "PgFloat":
       case "PgDoublePrecision":
         return { tsType: "number", dbType: "DOUBLE" };
+      // `real()` builds a `PgReal`, which matched no arm and fell through to the coarse
+      // `/Numeric|Float|Double|Real/i` below, so a real column was labelled NUMERIC while v1
+      // called it REAL. The arm above used to name `PgFloat` alongside `PgDoublePrecision`, and
+      // no such class exists in pg-core on either major: `float` is MySQL's spelling and Gel's
+      // is `GelReal`, both of which are matched elsewhere. Enumerated from the module's own
+      // exports on 0.45.2 and on 1.0.0-rc.4, which name only PgReal and PgDoublePrecision.
+      case "PgReal":
+        return { tsType: "number", dbType: "REAL" };
+      // 0.4x names a point and a line by their mode. `point()` is a `PgPointTuple` and `line()` a
+      // `PgLineTuple`, whose entity kind is `PgLine` while its constructor is not, and both used
+      // to fall through to `/Point|Line/i` and come back `string`. The driver hands back [x, y]
+      // and [a, b, c], so a select schema built on 0.4x refused every row, and an insert schema
+      // took the one string form `mapToDriverValue` turns into something Postgres rejects.
+      case "PgPointTuple":
+        return { tsType: "[number, number]", dbType: "POINT" };
+      case "PgLineTuple":
+        return { tsType: "[number, number, number]", dbType: "LINE" };
       case "PgJson":
       case "PgJsonb":
         return { tsType: "any", dbType: ctor === "PgJsonb" ? "JSONB" : "JSON" };
@@ -614,11 +651,10 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           if (/Json/i.test(ctor)) return { tsType: "any", dbType: "JSON" };
           if (/Text/i.test(ctor)) return { tsType: "string", dbType: "TEXT" };
           if (/Bytes/i.test(ctor)) return { tsType: "Uint8Array", dbType: "BLOB" };
+          if (/Bool/i.test(ctor)) return { tsType: "boolean", dbType: "BOOLEAN" };
           if (/TimestampTz/i.test(ctor)) return { tsType: "Date", dbType: "TIMESTAMPTZ" };
-          if (/Timestamp/i.test(ctor)) return { tsType: "string", dbType: "TIMESTAMP" };
-          if (/LocalDateString|LocalTime/i.test(ctor)) return { tsType: "string", dbType: "TEXT" };
-          if (/DateDuration|RelDuration|Duration/i.test(ctor))
-            return { tsType: "string", dbType: "TEXT" };
+          if (/Timestamp|LocalDateString|LocalTime|DateDuration|RelDuration|Duration/i.test(ctor))
+            return { tsType: "unknown", dbType: "UNKNOWN" };
         }
         return { tsType: "unknown", dbType: "UNKNOWN" };
     }
@@ -663,8 +699,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       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 jsonShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : void 0;
-      const shape = (v1?.shape ?? jsonShape)?.kind;
+      const fallbackShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : TUPLE_CLASS_SHAPES[String(col?.constructor?.name ?? "")];
+      const shape = (v1?.shape ?? fallbackShape)?.kind;
       const finalTs = v1?.tsType ?? tsType;
       const wide = (finalTs === "unknown" || finalTs === "any") && (!shape || shape === "custom");
       if (wide) {
@@ -693,7 +729,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         // that spread has nothing to say and this is the only source.
         ...arrayDims ? { arrayDimensions: arrayDims } : {},
         // Only where v1 did not already describe the value, so a shaped column keeps its shape.
-        ...jsonShape && !v1?.shape ? { shape: jsonShape } : {},
+        ...fallbackShape && !v1?.shape ? { shape: fallbackShape } : {},
         ...byteCap && v1?.maxBytes === void 0 ? { maxBytes: byteCap } : {}
       });
     }
@@ -813,12 +849,14 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     const relations = [];
     const enums = [];
     const columnEnums = [];
+    const viewTables = [];
     for (const [name, val] of Object.entries(exportsObj)) {
       try {
         const cols = this.getSymbol(val, "drizzle:Columns");
         if (cols && typeof cols === "object") {
           const table = this.analyzeTable(name, val, issues);
           tables.push(table);
+          if (isDrizzleView(val)) viewTables.push(table);
           for (const col of table.columns) {
             const enumVals = cols[col.name]?.enumValues;
             if (enumVals && enumVals.length) {
@@ -869,7 +907,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     let dialect = "unknown";
     const marks = /* @__PURE__ */ new Set();
     for (const [_, val] of Object.entries(exportsObj)) {
-      const cols = val?.[/* @__PURE__ */ Symbol.for("drizzle:Columns")];
+      const cols = this.getSymbol(val, "drizzle:Columns");
       if (!cols) continue;
       for (const c of Object.values(cols)) {
         const kind = c?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")];
@@ -886,6 +924,9 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     else if (/MySql|Mysql/i.test(names)) dialect = "mysql";
     else if (/Pg|Postgres/i.test(names)) dialect = "postgres";
     else if (/Gel/i.test(names)) dialect = "gel";
+    if (dialect === "sqlite") {
+      for (const view of viewTables) view.readOnly = true;
+    }
     if (dialect === "unknown" && tables.length) {
       issues.push({
         code: "DRZL_ANL_DIALECT",
@@ -971,12 +1012,67 @@ _SchemaAnalyzer.INT_RANGES = {
   MySqlBigInt64: ["-9223372036854775808", "9223372036854775807"],
   SingleStoreBigInt64: ["-9223372036854775808", "9223372036854775807"]
 };
+/**
+ * The numeric column classes that are not exact, and the magnitude each one can really hold.
+ *
+ * Only drizzle v1 states this outright, as a `float` or `double` semantic on `dataType`. On
+ * 0.4x the same columns reach the analyzer by class name, `INT_RANGES` was the only range table
+ * on that path, and so nothing said anything about them at all: not the range, and not that
+ * they are inexact. The parity gate measured seven of the ten classes below and reported DRZL
+ * differing from the first-party validator for the same major on all seven. The three
+ * SingleStore classes are in no fixture either pass carries and are covered by unit tests alone.
+ *
+ * Differing is what the gate reports, not what it forbids. Most of its waivers have DRZL
+ * accepting something official refuses and the run counts them; an earlier version of this
+ * sentence said the gate exists to forbid being looser, which the same commit's own success
+ * banner denies.
+ *
+ * `null` is a value in this table and is not the same as a class it does not name. It says the
+ * column is inexact and that no finite magnitude bound is truthful for it, which is the case for
+ * every 8 byte float: float8 is the JavaScript number's own format, so Postgres accepts every
+ * finite JS number into one, measured to `Number.MAX_VALUE`. Read with an own-property test for
+ * that reason, and because a plain object answers to `constructor` and `toString`.
+ *
+ * `integer: false` travels with every entry, bound or not, and what it decides depends on which.
+ * `isIntegerColumn` falls back to "declares both bounds" when the flag is absent, so on a bounded
+ * entry the flag is the only thing stopping the emitted schema calling `.int()` and refusing 1.5.
+ * On an unbounded one it decides nothing, measured both ways against the real function in
+ * `@drzl/validation-core`'s integer-column.spec.ts. It is stated there because it is true of the
+ * column, not because it guards anything. That spec is where the measurement moved when the
+ * analyzer's copy of it turned out to be a closed loop; this sentence went on naming
+ * floats-and-tuples-0.4x.spec.ts, which asserts the flag is present and nothing about what it
+ * decides.
+ *
+ * The widths are the type's, not the name's: MySQL and SingleStore `real` is a synonym for
+ * `double` unless REAL_AS_FLOAT is set, and SQLite `real` is an 8 byte IEEE float. Both are
+ * `number double` on drizzle v1, which is where these pairings come from.
+ */
+_SchemaAnalyzer.INEXACT_RANGES = {
+  // 4 byte floats, the one width a database refuses a magnitude for, and the two that have one
+  // refuse at different values. SingleStore is MySQL wire-compatible and unmeasured here, so it
+  // takes MySQL's rather than the wider of the two.
+  PgReal: PG_FLOAT4_RANGE,
+  MySqlFloat: MYSQL_FLOAT_RANGE,
+  SingleStoreFloat: MYSQL_FLOAT_RANGE,
+  // 8 byte floats, which hold every finite JS number
+  PgDoublePrecision: null,
+  MySqlDouble: null,
+  MySqlReal: null,
+  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
+};
 var SchemaAnalyzer = _SchemaAnalyzer;
 var index_default = SchemaAnalyzer;
 export {
   SchemaAnalyzer,
   index_default as default,
   describeV1Column,
+  isDrizzleView,
   isReadOnlyRelation,
   isRelationsV2,
   readRelationsV2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/analyzer",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -43,7 +43,7 @@
     "url": "https://github.com/sponsors/omar-dulaimi"
   },
   "scripts": {
-    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "build": "tsup src/index.ts --dts --format esm,cjs --clean",
     "lint": "eslint . --ext .ts",
     "test": "vitest run --testTimeout=20000"
   }