@drzl/analyzer 1.5.2 → 1.6.0

package/dist/index.cjs

@@ -35,7 +35,15 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_meta = {};
-var SchemaAnalyzer = class {
+function renderSqlLiteral(v) {
+  if (v === null || v === void 0) return "NULL";
+  if (typeof v === "number" || typeof v === "bigint") return String(v);
+  if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
+  if (v instanceof Date) return `'${v.toISOString()}'`;
+  if (Array.isArray(v)) return `(${v.map(renderSqlLiteral).join(", ")})`;
+  return `'${String(v).replace(/'/g, "''")}'`;
+}
+var _SchemaAnalyzer = class _SchemaAnalyzer {
   constructor(schemaPath) {
     this.schemaPath = schemaPath;
   }
@@ -172,6 +180,12 @@ var SchemaAnalyzer = class {
       if (Array.isArray(c?.value)) return c.value.join("");
       if (typeof c?.name === "string") return toTs(c.name);
       if (c?.queryChunks) return this.renderSql(c, toTs);
+      if (c === null || ["number", "string", "boolean", "bigint"].includes(typeof c)) {
+        return renderSqlLiteral(c);
+      }
+      if (typeof c === "object" && "value" in c) {
+        return renderSqlLiteral(c.value);
+      }
       return "?";
     }).join("").trim();
   }
@@ -243,6 +257,26 @@ var SchemaAnalyzer = class {
     }
     return out;
   }
+  /**
+   * Constraints the column definition already carries, which the analysis used to throw away.
+   *
+   * Everything here is read off Drizzle's own column instance, so it states what the schema
+   * states. Nothing is inferred from a name or guessed from a type.
+   */
+  columnConstraints(column) {
+    const ctor = column?.constructor?.name ?? "";
+    const out = {};
+    const length = column?.length ?? column?.config?.length;
+    if (typeof length === "number" && Number.isFinite(length) && length > 0) {
+      out.maxLength = length;
+    }
+    const range = _SchemaAnalyzer.INT_RANGES[ctor];
+    if (range) {
+      [out.min, out.max] = range;
+    }
+    if (/^(Pg)?UUID$/i.test(ctor) || /Uuid$/i.test(ctor)) out.format = "uuid";
+    return out;
+  }
   mapColumnType(column) {
     const ctor = column?.constructor?.name ?? "";
     switch (ctor) {
@@ -264,6 +298,14 @@ var SchemaAnalyzer = class {
       case "PgInteger":
       case "PgSmallInt":
         return { tsType: "number", dbType: "INTEGER" };
+      // Drizzle names these by their mode: `PgBigInt53` for `{ mode: 'number' }` and
+      // `PgBigInt64` for `{ mode: 'bigint' }`. `PgBigInt` matched neither, so both fell through
+      // to the regex arm and came back as `bigint`, which is wrong for the number mode: the
+      // value really is a JS number there, and a schema demanding a bigint rejects every row.
+      case "PgBigInt53":
+        return { tsType: "number", dbType: "BIGINT" };
+      case "PgBigInt64":
+        return { tsType: "bigint", dbType: "BIGINT" };
       case "PgBigInt":
         return {
           tsType: column?.config?.mode === "number" ? "number" : "bigint",
@@ -277,6 +319,9 @@ var SchemaAnalyzer = class {
       case "PgVarchar":
       case "PgChar":
         return { tsType: "string", dbType: "TEXT" };
+      // Drizzle spells it `PgUUID`. `PgUuid` matched nothing, so every uuid column fell through
+      // to the regex arm below and came back as plain TEXT, losing the format.
+      case "PgUUID":
       case "PgUuid":
         return { tsType: "string", dbType: "UUID" };
       case "PgBoolean":
@@ -407,7 +452,8 @@ var SchemaAnalyzer = class {
         isGenerated,
         defaultExpression: void 0,
         references,
-        enumValues: Array.isArray(ev) ? ev : void 0
+        enumValues: Array.isArray(ev) ? ev : void 0,
+        ...this.columnConstraints(col)
       });
     }
     const name = this.getSymbol(tbl, "drizzle:Name") || tsName;
@@ -568,27 +614,32 @@ var SchemaAnalyzer = class {
       enums.push(candidate);
     }
     let dialect = "unknown";
-    const ctorNames = /* @__PURE__ */ new Set();
+    const marks = /* @__PURE__ */ new Set();
     for (const [_, val] of Object.entries(exportsObj)) {
       const cols = val?.[/* @__PURE__ */ Symbol.for("drizzle:Columns")];
-      if (cols) {
-        for (const c of Object.values(cols)) {
-          const n = c?.constructor?.name;
-          if (n) ctorNames.add(n);
-        }
+      if (!cols) continue;
+      for (const c of Object.values(cols)) {
+        const kind = c?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")];
+        if (typeof kind === "string") marks.add(kind);
+        const n = c?.constructor?.name;
+        if (n) marks.add(n);
       }
     }
-    const names = Array.from(ctorNames).join(",");
+    const names = Array.from(marks).join(",");
     if (/SQLite/i.test(names)) dialect = "sqlite";
-    else if (/Pg|Postgres/i.test(names)) dialect = "postgres";
-    else if (/MySql|Mysql/i.test(names)) dialect = "mysql";
     else if (/SingleStore/i.test(names)) dialect = "singlestore";
+    else if (/Cockroach/i.test(names)) dialect = "cockroach";
+    else if (/MsSql/i.test(names)) dialect = "mssql";
+    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 === "unknown") {
-      const looksSqlite = tables.some(
-        (t) => t.columns.some((c) => ["INTEGER", "TEXT", "REAL", "BLOB", "NUMERIC"].includes(c.dbType))
-      );
-      if (looksSqlite) dialect = "sqlite";
+    if (dialect === "unknown" && tables.length) {
+      issues.push({
+        code: "DRZL_ANL_DIALECT",
+        level: "warn",
+        message: `Could not identify the Drizzle dialect for this schema${names ? `; saw column kinds: ${Array.from(marks).slice(0, 6).join(", ")}` : ""}.`,
+        hint: "Column types will fall back to their coarse defaults. If this is a dialect DRZL does not know yet, please open an issue."
+      });
     }
     if (opts.includeRelations) {
       relations.push(...this.inferManyToMany(tables));
@@ -628,6 +679,42 @@ var SchemaAnalyzer = class {
     };
   }
 };
+/**
+ * The range an integer column can actually hold, keyed off the Drizzle column class.
+ *
+ * Matches what `drizzle-orm/zod` emits, measured at 1.0.0-rc.4. The two bigint modes differ on
+ * purpose: in `{ mode: 'number' }` the value arrives as a JS number, so the real ceiling is
+ * `Number.MAX_SAFE_INTEGER` rather than the column's, and bounding at the column's would
+ * promise a precision that cannot survive the round trip.
+ */
+_SchemaAnalyzer.INT_RANGES = {
+  // 8 bit
+  MySqlTinyInt: ["-128", "127"],
+  SQLiteInteger: ["-9223372036854775808", "9223372036854775807"],
+  // 16 bit
+  PgSmallInt: ["-32768", "32767"],
+  PgSmallSerial: ["1", "32767"],
+  MySqlSmallInt: ["-32768", "32767"],
+  SingleStoreSmallInt: ["-32768", "32767"],
+  // 24 bit
+  MySqlMediumInt: ["-8388608", "8388607"],
+  // 32 bit
+  PgInteger: ["-2147483648", "2147483647"],
+  PgSerial: ["1", "2147483647"],
+  MySqlInt: ["-2147483648", "2147483647"],
+  SingleStoreInt: ["-2147483648", "2147483647"],
+  // 53 bit, the JS safe-integer ceiling rather than the column's
+  PgBigInt53: ["-9007199254740991", "9007199254740991"],
+  PgBigSerial53: ["1", "9007199254740991"],
+  MySqlBigInt53: ["-9007199254740991", "9007199254740991"],
+  SingleStoreBigInt53: ["-9007199254740991", "9007199254740991"],
+  // 64 bit, representable because the value is a bigint
+  PgBigInt64: ["-9223372036854775808", "9223372036854775807"],
+  PgBigSerial64: ["1", "9223372036854775807"],
+  MySqlBigInt64: ["-9223372036854775808", "9223372036854775807"],
+  SingleStoreBigInt64: ["-9223372036854775808", "9223372036854775807"]
+};
+var SchemaAnalyzer = _SchemaAnalyzer;
 var index_default = SchemaAnalyzer;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.d.cts

@@ -1,4 +1,8 @@
-type Dialect = 'sqlite' | 'postgres' | 'mysql' | 'singlestore' | 'gel' | 'unknown';
+/**
+ * `mssql` and `cockroach` arrived with Drizzle v1. `gel` was removed in the same release, but
+ * stays here so an analysis of a 0.4x schema still names what it found.
+ */
+type Dialect = 'sqlite' | 'postgres' | 'mysql' | 'singlestore' | 'mssql' | 'cockroach' | 'gel' | 'unknown';
 interface Issue {
     code: string;
     level: 'info' | 'warn' | 'error';
@@ -31,6 +35,26 @@ interface Column {
         onUpdate?: string;
     };
     enumValues?: string[];
+    /**
+     * Declared character limit, from `varchar('x', { length: 255 })` and friends.
+     *
+     * The column has always known this and the analysis discarded it, so generated schemas
+     * accepted a 300 character value that the database then rejected. Absent where the type has
+     * no limit, since claiming one would invent a constraint the schema never stated.
+     */
+    maxLength?: number;
+    /**
+     * Inclusive bounds for an integer column, as decimal strings.
+     *
+     * Strings rather than numbers because a 64 bit bound is not representable as a JS number:
+     * `9223372036854775807` rounds to `9223372036854775808` the moment it becomes one, so a
+     * numeric field here would silently emit a wrong bound. Absent for floats and for `numeric`,
+     * which have no integer range.
+     */
+    min?: string;
+    max?: string;
+    /** A string column with a known shape, currently only `uuid`. */
+    format?: 'uuid';
 }
 interface Key {
     name?: string;
@@ -171,6 +195,22 @@ declare class SchemaAnalyzer {
      * it a join table would invent a relation the author never declared.
      */
     private inferManyToMany;
+    /**
+     * The range an integer column can actually hold, keyed off the Drizzle column class.
+     *
+     * Matches what `drizzle-orm/zod` emits, measured at 1.0.0-rc.4. The two bigint modes differ on
+     * purpose: in `{ mode: 'number' }` the value arrives as a JS number, so the real ceiling is
+     * `Number.MAX_SAFE_INTEGER` rather than the column's, and bounding at the column's would
+     * promise a precision that cannot survive the round trip.
+     */
+    private static readonly INT_RANGES;
+    /**
+     * Constraints the column definition already carries, which the analysis used to throw away.
+     *
+     * Everything here is read off Drizzle's own column instance, so it states what the schema
+     * states. Nothing is inferred from a name or guessed from a type.
+     */
+    private columnConstraints;
     private mapColumnType;
     private analyzeTable;
     analyze(opts?: AnalyzeOptions): Promise<Analysis>;

package/dist/index.d.ts

@@ -1,4 +1,8 @@
-type Dialect = 'sqlite' | 'postgres' | 'mysql' | 'singlestore' | 'gel' | 'unknown';
+/**
+ * `mssql` and `cockroach` arrived with Drizzle v1. `gel` was removed in the same release, but
+ * stays here so an analysis of a 0.4x schema still names what it found.
+ */
+type Dialect = 'sqlite' | 'postgres' | 'mysql' | 'singlestore' | 'mssql' | 'cockroach' | 'gel' | 'unknown';
 interface Issue {
     code: string;
     level: 'info' | 'warn' | 'error';
@@ -31,6 +35,26 @@ interface Column {
         onUpdate?: string;
     };
     enumValues?: string[];
+    /**
+     * Declared character limit, from `varchar('x', { length: 255 })` and friends.
+     *
+     * The column has always known this and the analysis discarded it, so generated schemas
+     * accepted a 300 character value that the database then rejected. Absent where the type has
+     * no limit, since claiming one would invent a constraint the schema never stated.
+     */
+    maxLength?: number;
+    /**
+     * Inclusive bounds for an integer column, as decimal strings.
+     *
+     * Strings rather than numbers because a 64 bit bound is not representable as a JS number:
+     * `9223372036854775807` rounds to `9223372036854775808` the moment it becomes one, so a
+     * numeric field here would silently emit a wrong bound. Absent for floats and for `numeric`,
+     * which have no integer range.
+     */
+    min?: string;
+    max?: string;
+    /** A string column with a known shape, currently only `uuid`. */
+    format?: 'uuid';
 }
 interface Key {
     name?: string;
@@ -171,6 +195,22 @@ declare class SchemaAnalyzer {
      * it a join table would invent a relation the author never declared.
      */
     private inferManyToMany;
+    /**
+     * The range an integer column can actually hold, keyed off the Drizzle column class.
+     *
+     * Matches what `drizzle-orm/zod` emits, measured at 1.0.0-rc.4. The two bigint modes differ on
+     * purpose: in `{ mode: 'number' }` the value arrives as a JS number, so the real ceiling is
+     * `Number.MAX_SAFE_INTEGER` rather than the column's, and bounding at the column's would
+     * promise a precision that cannot survive the round trip.
+     */
+    private static readonly INT_RANGES;
+    /**
+     * Constraints the column definition already carries, which the analysis used to throw away.
+     *
+     * Everything here is read off Drizzle's own column instance, so it states what the schema
+     * states. Nothing is inferred from a name or guessed from a type.
+     */
+    private columnConstraints;
     private mapColumnType;
     private analyzeTable;
     analyze(opts?: AnalyzeOptions): Promise<Analysis>;

package/dist/index.js

@@ -1,5 +1,13 @@
 // src/index.ts
-var SchemaAnalyzer = class {
+function renderSqlLiteral(v) {
+  if (v === null || v === void 0) return "NULL";
+  if (typeof v === "number" || typeof v === "bigint") return String(v);
+  if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
+  if (v instanceof Date) return `'${v.toISOString()}'`;
+  if (Array.isArray(v)) return `(${v.map(renderSqlLiteral).join(", ")})`;
+  return `'${String(v).replace(/'/g, "''")}'`;
+}
+var _SchemaAnalyzer = class _SchemaAnalyzer {
   constructor(schemaPath) {
     this.schemaPath = schemaPath;
   }
@@ -136,6 +144,12 @@ var SchemaAnalyzer = class {
       if (Array.isArray(c?.value)) return c.value.join("");
       if (typeof c?.name === "string") return toTs(c.name);
       if (c?.queryChunks) return this.renderSql(c, toTs);
+      if (c === null || ["number", "string", "boolean", "bigint"].includes(typeof c)) {
+        return renderSqlLiteral(c);
+      }
+      if (typeof c === "object" && "value" in c) {
+        return renderSqlLiteral(c.value);
+      }
       return "?";
     }).join("").trim();
   }
@@ -207,6 +221,26 @@ var SchemaAnalyzer = class {
     }
     return out;
   }
+  /**
+   * Constraints the column definition already carries, which the analysis used to throw away.
+   *
+   * Everything here is read off Drizzle's own column instance, so it states what the schema
+   * states. Nothing is inferred from a name or guessed from a type.
+   */
+  columnConstraints(column) {
+    const ctor = column?.constructor?.name ?? "";
+    const out = {};
+    const length = column?.length ?? column?.config?.length;
+    if (typeof length === "number" && Number.isFinite(length) && length > 0) {
+      out.maxLength = length;
+    }
+    const range = _SchemaAnalyzer.INT_RANGES[ctor];
+    if (range) {
+      [out.min, out.max] = range;
+    }
+    if (/^(Pg)?UUID$/i.test(ctor) || /Uuid$/i.test(ctor)) out.format = "uuid";
+    return out;
+  }
   mapColumnType(column) {
     const ctor = column?.constructor?.name ?? "";
     switch (ctor) {
@@ -228,6 +262,14 @@ var SchemaAnalyzer = class {
       case "PgInteger":
       case "PgSmallInt":
         return { tsType: "number", dbType: "INTEGER" };
+      // Drizzle names these by their mode: `PgBigInt53` for `{ mode: 'number' }` and
+      // `PgBigInt64` for `{ mode: 'bigint' }`. `PgBigInt` matched neither, so both fell through
+      // to the regex arm and came back as `bigint`, which is wrong for the number mode: the
+      // value really is a JS number there, and a schema demanding a bigint rejects every row.
+      case "PgBigInt53":
+        return { tsType: "number", dbType: "BIGINT" };
+      case "PgBigInt64":
+        return { tsType: "bigint", dbType: "BIGINT" };
       case "PgBigInt":
         return {
           tsType: column?.config?.mode === "number" ? "number" : "bigint",
@@ -241,6 +283,9 @@ var SchemaAnalyzer = class {
       case "PgVarchar":
       case "PgChar":
         return { tsType: "string", dbType: "TEXT" };
+      // Drizzle spells it `PgUUID`. `PgUuid` matched nothing, so every uuid column fell through
+      // to the regex arm below and came back as plain TEXT, losing the format.
+      case "PgUUID":
       case "PgUuid":
         return { tsType: "string", dbType: "UUID" };
       case "PgBoolean":
@@ -371,7 +416,8 @@ var SchemaAnalyzer = class {
         isGenerated,
         defaultExpression: void 0,
         references,
-        enumValues: Array.isArray(ev) ? ev : void 0
+        enumValues: Array.isArray(ev) ? ev : void 0,
+        ...this.columnConstraints(col)
       });
     }
     const name = this.getSymbol(tbl, "drizzle:Name") || tsName;
@@ -532,27 +578,32 @@ var SchemaAnalyzer = class {
       enums.push(candidate);
     }
     let dialect = "unknown";
-    const ctorNames = /* @__PURE__ */ new Set();
+    const marks = /* @__PURE__ */ new Set();
     for (const [_, val] of Object.entries(exportsObj)) {
       const cols = val?.[/* @__PURE__ */ Symbol.for("drizzle:Columns")];
-      if (cols) {
-        for (const c of Object.values(cols)) {
-          const n = c?.constructor?.name;
-          if (n) ctorNames.add(n);
-        }
+      if (!cols) continue;
+      for (const c of Object.values(cols)) {
+        const kind = c?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")];
+        if (typeof kind === "string") marks.add(kind);
+        const n = c?.constructor?.name;
+        if (n) marks.add(n);
       }
     }
-    const names = Array.from(ctorNames).join(",");
+    const names = Array.from(marks).join(",");
     if (/SQLite/i.test(names)) dialect = "sqlite";
-    else if (/Pg|Postgres/i.test(names)) dialect = "postgres";
-    else if (/MySql|Mysql/i.test(names)) dialect = "mysql";
     else if (/SingleStore/i.test(names)) dialect = "singlestore";
+    else if (/Cockroach/i.test(names)) dialect = "cockroach";
+    else if (/MsSql/i.test(names)) dialect = "mssql";
+    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 === "unknown") {
-      const looksSqlite = tables.some(
-        (t) => t.columns.some((c) => ["INTEGER", "TEXT", "REAL", "BLOB", "NUMERIC"].includes(c.dbType))
-      );
-      if (looksSqlite) dialect = "sqlite";
+    if (dialect === "unknown" && tables.length) {
+      issues.push({
+        code: "DRZL_ANL_DIALECT",
+        level: "warn",
+        message: `Could not identify the Drizzle dialect for this schema${names ? `; saw column kinds: ${Array.from(marks).slice(0, 6).join(", ")}` : ""}.`,
+        hint: "Column types will fall back to their coarse defaults. If this is a dialect DRZL does not know yet, please open an issue."
+      });
     }
     if (opts.includeRelations) {
       relations.push(...this.inferManyToMany(tables));
@@ -592,6 +643,42 @@ var SchemaAnalyzer = class {
     };
   }
 };
+/**
+ * The range an integer column can actually hold, keyed off the Drizzle column class.
+ *
+ * Matches what `drizzle-orm/zod` emits, measured at 1.0.0-rc.4. The two bigint modes differ on
+ * purpose: in `{ mode: 'number' }` the value arrives as a JS number, so the real ceiling is
+ * `Number.MAX_SAFE_INTEGER` rather than the column's, and bounding at the column's would
+ * promise a precision that cannot survive the round trip.
+ */
+_SchemaAnalyzer.INT_RANGES = {
+  // 8 bit
+  MySqlTinyInt: ["-128", "127"],
+  SQLiteInteger: ["-9223372036854775808", "9223372036854775807"],
+  // 16 bit
+  PgSmallInt: ["-32768", "32767"],
+  PgSmallSerial: ["1", "32767"],
+  MySqlSmallInt: ["-32768", "32767"],
+  SingleStoreSmallInt: ["-32768", "32767"],
+  // 24 bit
+  MySqlMediumInt: ["-8388608", "8388607"],
+  // 32 bit
+  PgInteger: ["-2147483648", "2147483647"],
+  PgSerial: ["1", "2147483647"],
+  MySqlInt: ["-2147483648", "2147483647"],
+  SingleStoreInt: ["-2147483648", "2147483647"],
+  // 53 bit, the JS safe-integer ceiling rather than the column's
+  PgBigInt53: ["-9007199254740991", "9007199254740991"],
+  PgBigSerial53: ["1", "9007199254740991"],
+  MySqlBigInt53: ["-9007199254740991", "9007199254740991"],
+  SingleStoreBigInt53: ["-9007199254740991", "9007199254740991"],
+  // 64 bit, representable because the value is a bigint
+  PgBigInt64: ["-9223372036854775808", "9223372036854775807"],
+  PgBigSerial64: ["1", "9223372036854775807"],
+  MySqlBigInt64: ["-9223372036854775808", "9223372036854775807"],
+  SingleStoreBigInt64: ["-9223372036854775808", "9223372036854775807"]
+};
+var SchemaAnalyzer = _SchemaAnalyzer;
 var index_default = SchemaAnalyzer;
 export {
   SchemaAnalyzer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/analyzer",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",