@drzl/analyzer 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -52,6 +52,197 @@ var SchemaAnalyzer = class {
     }
     return table[Symbol.for(key)];
   }
+  /**
+   * Drizzle keys the Columns object by TypeScript property name, but every other piece of
+   * metadata (foreign keys, indexes, composite primary keys) reports the *database* column
+   * name. We report the TS name, since that is what a generated schema has to spell, so
+   * anything coming from that other metadata has to be translated back.
+   *
+   * Falls through to the input when a name is unknown, which keeps raw SQL expressions and
+   * columns belonging to another table readable rather than dropping them.
+   */
+  dbToTsNames(columnsObj) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [tsName, col] of Object.entries(columnsObj ?? {})) {
+      const dbName = col?.name;
+      if (typeof dbName === "string") map.set(dbName, tsName);
+    }
+    return (dbName) => {
+      const raw = typeof dbName === "string" ? dbName : dbName?.name ?? String(dbName);
+      return map.get(raw) ?? raw;
+    };
+  }
+  /**
+   * Entries from a table's third argument, the extra-config callback.
+   *
+   * Drizzle invokes this callback with the table's ExtraConfigColumns, NOT with the table.
+   * Passing the table throws, and because the whole block used to sit under a bare `catch {}`
+   * the throw was swallowed and every index, unique index, composite primary key, check
+   * constraint and table-level foreign key silently vanished from the analysis.
+   *
+   * Both shapes are accepted: modern Drizzle returns an array, older versions an object.
+   */
+  extraConfigEntries(tbl, issues, tableName) {
+    const builder = this.getSymbol(tbl, "drizzle:ExtraConfigBuilder");
+    if (typeof builder !== "function") return [];
+    const cols = this.getSymbol(tbl, "drizzle:ExtraConfigColumns") ?? tbl;
+    try {
+      const built = builder(cols);
+      if (!built) return [];
+      return Array.isArray(built) ? built : Object.values(built);
+    } catch (e) {
+      issues.push({
+        code: "DRZL_ANL_EXTRACONFIG",
+        level: "warn",
+        message: `Could not evaluate the extra-config callback for table "${tableName}": ${e.message}`,
+        hint: "Indexes, composite keys, checks and table-level foreign keys will be missing for this table."
+      });
+      return [];
+    }
+  }
+  /**
+   * Foreign keys declared inline with `.references()`.
+   *
+   * Drizzle stores these per dialect under `drizzle:PgInlineForeignKeys`,
+   * `drizzle:MySqlInlineForeignKeys` and `drizzle:SQLiteInlineForeignKeys`. Matching the
+   * suffix rather than listing the three keeps new dialects working without a change here.
+   * SingleStore has no entry because it does not support foreign keys at all, which is why
+   * `.references()` is not even a function there.
+   */
+  inlineForeignKeys(tbl) {
+    try {
+      for (const s of Object.getOwnPropertySymbols(tbl)) {
+        if (/InlineForeignKeys$/.test(s.description ?? "")) {
+          const v = tbl[s];
+          if (Array.isArray(v)) return v;
+        }
+      }
+    } catch {
+    }
+    return [];
+  }
+  /**
+   * Normalise one foreign key, inline or table-level, into a common shape.
+   *
+   * `.reference()` yields the resolved columns on both. The referential actions do not live
+   * in the same place: a built ForeignKey exposes `onDelete`/`onUpdate` as strings, while an
+   * unbuilt ForeignKeyBuilder exposes them as the chainable setter functions and keeps the
+   * values in `_onDelete`/`_onUpdate`. Reading the wrong one yields a function where a string
+   * is expected, so check the type rather than the property's presence.
+   *
+   * Postgres reports 'no action' where MySQL and SQLite report nothing, for identical schemas.
+   * Since 'no action' *is* the default, it is normalised away so the same schema analyses the
+   * same across dialects.
+   */
+  readForeignKey(fk, toTs) {
+    let ref;
+    try {
+      ref = fk?.reference?.();
+    } catch {
+      return void 0;
+    }
+    if (!ref?.foreignTable) return void 0;
+    const action = (v, fallback) => {
+      const raw = typeof v === "string" ? v : typeof fallback === "string" ? fallback : void 0;
+      return raw && raw.toLowerCase() !== "no action" ? raw : void 0;
+    };
+    const foreignColumnsObj = this.getSymbol(ref.foreignTable, "drizzle:Columns") ?? {};
+    const toForeignTs = this.dbToTsNames(foreignColumnsObj);
+    return {
+      columns: (ref.columns ?? []).map((c) => toTs(c?.name)),
+      foreignTable: this.getSymbol(ref.foreignTable, "drizzle:Name") ?? "unknown",
+      foreignColumns: (ref.foreignColumns ?? []).map((c) => toForeignTs(c?.name)),
+      onDelete: action(fk?.onDelete, fk?._onDelete),
+      onUpdate: action(fk?.onUpdate, fk?._onUpdate),
+      name: typeof fk?.getName === "function" ? void 0 : fk?.name
+    };
+  }
+  /**
+   * Render a Drizzle SQL template back into readable text.
+   *
+   * A `sql` tagged template is stored as alternating chunks: literal fragments holding a
+   * string array, and column references. `String()` on that array yields "[object Object]",
+   * so a check constraint's expression has to be assembled rather than stringified.
+   * Anything unrecognised becomes `?`, which is honest about the gap without inventing SQL.
+   */
+  renderSql(value, toTs) {
+    const chunks = value?.queryChunks;
+    if (!Array.isArray(chunks)) return String(value ?? "");
+    return chunks.map((c) => {
+      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);
+      return "?";
+    }).join("").trim();
+  }
+  /** A value produced by Drizzle's `relations()` helper: a source table plus a callback. */
+  isRelationsObject(val) {
+    return !!val && typeof val === "object" && typeof val.config === "function" && !!this.getSymbol(val.table, "drizzle:Columns");
+  }
+  /**
+   * Read the relations declared by `relations(table, ({ one, many }) => ...)`.
+   *
+   * The previous implementation looked for `val.config.relations`. That property does not
+   * exist: `config` is a *function*, so the expression was always undefined and the branch
+   * never ran. Nothing failed loudly, relations simply came back empty forever.
+   *
+   * `config` cannot just be read, it has to be invoked with the builder Drizzle would pass.
+   * Rather than depend on drizzle-orm to obtain the real builder, which this package
+   * deliberately does not do anywhere else, a stand-in supplies the only two functions a
+   * user's callback can call. `relations()` wraps that callback and calls `.withFieldName()`
+   * 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 make = (kind) => (table, cfg) => ({
+      kind,
+      referencedTable: table,
+      cfg,
+      withFieldName(n) {
+        this.fieldName = n;
+        return this;
+      }
+    });
+    try {
+      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");
+        if (to) out.push({ kind: rel.kind, from, to });
+      }
+      return out;
+    } catch (e) {
+      issues.push({
+        code: "DRZL_ANL_RELATIONS",
+        level: "warn",
+        message: `Could not read the relations declared in "${exportName}": ${e.message}`,
+        hint: "Relations for this table will be missing from the analysis."
+      });
+      return [];
+    }
+  }
+  /**
+   * Infer many-to-many links through a join table.
+   *
+   * A join table is taken to be one whose every column participates in a foreign key, and
+   * which points at exactly two distinct tables. Requiring *all* columns to be foreign keys
+   * is deliberate: a table carrying its own data is a real entity, not plumbing, and calling
+   * it a join table would invent a relation the author never declared.
+   */
+  inferManyToMany(tables) {
+    const out = [];
+    for (const t of tables) {
+      const fks = t.foreignKeys ?? [];
+      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))];
+      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 });
+    }
+    return out;
+  }
   mapColumnType(column) {
     const ctor = column?.constructor?.name ?? "";
     switch (ctor) {
@@ -67,14 +258,17 @@ var SchemaAnalyzer = class {
       case "SQLiteBlob":
         return { tsType: "Uint8Array", dbType: "BLOB" };
       case "SQLiteNumeric":
-        return { tsType: "number", dbType: "NUMERIC" };
+        return { tsType: "string", dbType: "NUMERIC" };
       case "SQLiteBoolean":
         return { tsType: "boolean", dbType: "INTEGER" };
       case "PgInteger":
       case "PgSmallInt":
         return { tsType: "number", dbType: "INTEGER" };
       case "PgBigInt":
-        return { tsType: "bigint", dbType: "BIGINT" };
+        return {
+          tsType: column?.config?.mode === "number" ? "number" : "bigint",
+          dbType: "BIGINT"
+        };
       case "PgSerial":
       case "PgSmallSerial":
       case "PgBigSerial":
@@ -92,9 +286,10 @@ var SchemaAnalyzer = class {
       case "PgDate":
         return { tsType: "Date", dbType: "TIMESTAMP" };
       case "PgNumeric":
+        return { tsType: "string", dbType: "NUMERIC" };
       case "PgFloat":
       case "PgDoublePrecision":
-        return { tsType: "number", dbType: "NUMERIC" };
+        return { tsType: "number", dbType: "DOUBLE" };
       case "PgJson":
       case "PgJsonb":
         return { tsType: "any", dbType: ctor === "PgJsonb" ? "JSONB" : "JSON" };
@@ -173,12 +368,13 @@ var SchemaAnalyzer = class {
         return { tsType: "unknown", dbType: "UNKNOWN" };
     }
   }
-  analyzeTable(tsName, tbl) {
+  analyzeTable(tsName, tbl, issues = []) {
     const columnsObj = this.getSymbol(tbl, "drizzle:Columns") ?? {};
     const columns = [];
     const unique = [];
     const indexes = [];
     const checks = [];
+    const foreignKeys = [];
     const pkCols = [];
     const uniqueGroups = /* @__PURE__ */ new Map();
     for (const [colName, col] of Object.entries(columnsObj)) {
@@ -191,13 +387,7 @@ var SchemaAnalyzer = class {
       const nullable = !col?.notNull && !col?.config?.notNull;
       const isGenerated = !!(col?.autoIncrement || col?.isGenerated);
       const hasDefault = col?.default !== void 0 || col?.config?.default !== void 0 || isGenerated;
-      const ref = col?.references;
-      const references = ref ? {
-        table: ref.table ?? "unknown",
-        column: ref.column ?? "id",
-        onDelete: ref.onDelete,
-        onUpdate: ref.onUpdate
-      } : void 0;
+      const references = void 0;
       const isUnique = !!(col?.isUnique || col?.config?.isUnique);
       const isPk = !!(col?.primary || col?.config?.primaryKey);
       if (isPk) pkCols.push(colName);
@@ -222,10 +412,11 @@ var SchemaAnalyzer = class {
     }
     const name = this.getSymbol(tbl, "drizzle:Name") || tsName;
     const schema = this.getSymbol(tbl, "drizzle:Schema");
+    const toTs = this.dbToTsNames(columnsObj);
     try {
-      const pkDef = tbl[Symbol.for("drizzle:PrimaryKey")];
+      const pkDef = this.getSymbol(tbl, "drizzle:PrimaryKey");
       if (pkDef && Array.isArray(pkDef.columns)) {
-        const cols = pkDef.columns.map((c) => c?.name ?? String(c)).filter(Boolean);
+        const cols = pkDef.columns.map((c) => toTs(c?.name)).filter(Boolean);
         if (cols.length) {
           pkCols.splice(0, pkCols.length, ...cols);
         }
@@ -233,36 +424,50 @@ var SchemaAnalyzer = class {
     } catch {
     }
     try {
-      const idxDef = tbl[Symbol.for("drizzle:Indexes")];
+      const idxDef = this.getSymbol(tbl, "drizzle:Indexes");
       if (Array.isArray(idxDef)) {
         for (const i of idxDef) {
-          const cols = (i?.columns ?? []).map((c) => c?.name ?? String(c)).filter(Boolean);
+          const cols = (i?.columns ?? []).map((c) => toTs(c?.name)).filter(Boolean);
           if (cols.length) indexes.push({ columns: cols, name: i?.name });
           if (i?.unique && cols.length) unique.push({ columns: cols });
         }
       }
     } catch {
     }
-    try {
-      const builder = tbl[Symbol.for("drizzle:ExtraConfigBuilder")];
-      if (typeof builder === "function") {
-        const built = builder(tbl);
-        const entries = Array.isArray(built) ? built.map((v, i) => [v?.config?.name ?? v?.name ?? `idx_${i}`, v]) : Object.entries(built ?? {});
-        for (const [key, val] of entries) {
-          const cfg = val?.config ?? val;
-          const cols = (cfg?.columns ?? []).map((c) => c?.name ?? String(c)).filter(Boolean);
-          const uniqueFlag = !!(cfg?.unique || /unique/i.test(val?.constructor?.name ?? "") || /unique/i.test(key));
-          const idxName = cfg?.name ?? val?.name ?? key;
-          const expr = cfg?.where || cfg?.expression;
-          if (expr && !cols.length) {
-            checks.push({ name: idxName, expression: String(expr) });
-          } else if (cols.length) {
-            indexes.push({ columns: cols, name: idxName });
-            if (uniqueFlag) unique.push({ columns: cols });
-          }
-        }
+    for (const entry of this.extraConfigEntries(tbl, issues, name)) {
+      if (typeof entry?.reference === "function") {
+        const fk = this.readForeignKey(entry, toTs);
+        if (fk) foreignKeys.push(fk);
+        continue;
       }
-    } catch {
+      if (entry?.value?.queryChunks && entry?.name !== void 0) {
+        checks.push({ name: entry.name, expression: this.renderSql(entry.value, toTs) });
+        continue;
+      }
+      const cfg = entry?.config ?? entry ?? {};
+      const cols = (cfg.columns ?? []).map((c) => toTs(c?.name)).filter(Boolean);
+      if (!cols.length) continue;
+      if (cfg.unique === void 0) {
+        pkCols.splice(0, pkCols.length, ...cols);
+        continue;
+      }
+      indexes.push({ columns: cols, name: cfg.name });
+      if (cfg.unique) unique.push({ columns: cols, name: cfg.name });
+    }
+    for (const fk of this.inlineForeignKeys(tbl)) {
+      const read = this.readForeignKey(fk, toTs);
+      if (read) foreignKeys.push(read);
+    }
+    for (const fk of foreignKeys) {
+      if (fk.columns.length !== 1 || fk.foreignColumns.length !== 1) continue;
+      const col = columns.find((c) => c.name === fk.columns[0]);
+      if (!col) continue;
+      col.references = {
+        table: fk.foreignTable,
+        column: fk.foreignColumns[0],
+        onDelete: fk.onDelete,
+        onUpdate: fk.onUpdate
+      };
     }
     return {
       name,
@@ -276,6 +481,7 @@ var SchemaAnalyzer = class {
       ],
       indexes: [...pkCols.length ? [{ columns: pkCols }] : [], ...indexes],
       checks,
+      foreignKeys,
       meta: {}
     };
   }
@@ -311,39 +517,29 @@ var SchemaAnalyzer = class {
     const tables = [];
     const relations = [];
     const enums = [];
+    const columnEnums = [];
     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);
+          const table = this.analyzeTable(name, val, issues);
           tables.push(table);
-          if (opts.includeRelations) {
-            for (const col of table.columns) {
-              if (col.references) {
-                relations.push({
-                  kind: "many",
-                  from: table.name,
-                  to: col.references.table
-                });
-              }
-              const enumVals = cols[col.name]?.enumValues;
-              if (enumVals && enumVals.length) {
-                const enumName = `${table.name}_${col.name}_enum`;
-                if (!enums.find((e) => e.name === enumName))
-                  enums.push({ name: enumName, values: enumVals });
-              }
+          for (const col of table.columns) {
+            const enumVals = cols[col.name]?.enumValues;
+            if (enumVals && enumVals.length) {
+              columnEnums.push({ name: `${table.name}_${col.name}_enum`, values: enumVals });
             }
           }
-        } else if (val?.config?.relations) {
-          const cfg = val.config.relations;
-          const base = name.replace(/Relations$/, "");
-          for (const entry of Object.values(cfg)) {
-            const target = entry?.referencedTable;
-            const targetName = target ? this.getSymbol(target, "drizzle:Name") : void 0;
-            if (targetName) {
-              relations.push({ kind: "many", from: base, to: targetName });
+          if (opts.includeRelations) {
+            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 });
             }
           }
+        } else if (this.isRelationsObject(val)) {
+          if (opts.includeRelations) {
+            relations.push(...this.readRelationsObject(val, name, issues));
+          }
         } else {
           const ev = val?.enumValues;
           if (Array.isArray(ev) && ev.every((x) => typeof x === "string")) {
@@ -365,6 +561,12 @@ var SchemaAnalyzer = class {
         });
       }
     }
+    for (const candidate of columnEnums) {
+      const key = JSON.stringify(candidate.values);
+      if (enums.some((e) => JSON.stringify(e.values) === key)) continue;
+      if (enums.some((e) => e.name === candidate.name)) continue;
+      enums.push(candidate);
+    }
     let dialect = "unknown";
     const ctorNames = /* @__PURE__ */ new Set();
     for (const [_, val] of Object.entries(exportsObj)) {
@@ -388,6 +590,9 @@ var SchemaAnalyzer = class {
       );
       if (looksSqlite) dialect = "sqlite";
     }
+    if (opts.includeRelations) {
+      relations.push(...this.inferManyToMany(tables));
+    }
     if (opts.includeRelations && opts.includeHeuristicRelations) {
       const tableNames = new Set(tables.map((t) => t.name));
       const findTarget = (base) => {
@@ -398,19 +603,27 @@ var SchemaAnalyzer = class {
       };
       for (const t of tables) {
         for (const c of t.columns) {
+          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: "many", from: t.name, to: target });
+            if (target) relations.push({ kind: "one", from: t.name, to: target });
           }
         }
       }
     }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = relations.filter((r) => {
+      const key = `${r.kind}|${r.from}|${r.to}|${r.via ?? ""}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
     return {
       dialect,
       tables,
       enums,
-      relations,
+      relations: deduped,
       issues
     };
   }

package/dist/index.d.cts

@@ -44,6 +44,21 @@ interface Check {
     name?: string;
     expression?: string;
 }
+/**
+ * A foreign key as declared, which may span several columns. Single-column keys are also
+ * mirrored onto `Column.references` for convenience; composite ones exist only here, because
+ * they cannot be attributed to any one column.
+ *
+ * Column names are TypeScript property names, matching `Column.name`.
+ */
+interface ForeignKey {
+    name?: string;
+    columns: string[];
+    foreignTable: string;
+    foreignColumns: string[];
+    onDelete?: string;
+    onUpdate?: string;
+}
 interface Table {
     name: string;
     tsName: string;
@@ -53,6 +68,7 @@ interface Table {
     unique: Key[];
     indexes: Index[];
     checks?: Check[];
+    foreignKeys?: ForeignKey[];
     meta?: Record<string, unknown>;
 }
 interface Enum {
@@ -76,9 +92,88 @@ declare class SchemaAnalyzer {
     private readonly schemaPath;
     constructor(schemaPath: string);
     private getSymbol;
+    /**
+     * Drizzle keys the Columns object by TypeScript property name, but every other piece of
+     * metadata (foreign keys, indexes, composite primary keys) reports the *database* column
+     * name. We report the TS name, since that is what a generated schema has to spell, so
+     * anything coming from that other metadata has to be translated back.
+     *
+     * Falls through to the input when a name is unknown, which keeps raw SQL expressions and
+     * columns belonging to another table readable rather than dropping them.
+     */
+    private dbToTsNames;
+    /**
+     * Entries from a table's third argument, the extra-config callback.
+     *
+     * Drizzle invokes this callback with the table's ExtraConfigColumns, NOT with the table.
+     * Passing the table throws, and because the whole block used to sit under a bare `catch {}`
+     * the throw was swallowed and every index, unique index, composite primary key, check
+     * constraint and table-level foreign key silently vanished from the analysis.
+     *
+     * Both shapes are accepted: modern Drizzle returns an array, older versions an object.
+     */
+    private extraConfigEntries;
+    /**
+     * Foreign keys declared inline with `.references()`.
+     *
+     * Drizzle stores these per dialect under `drizzle:PgInlineForeignKeys`,
+     * `drizzle:MySqlInlineForeignKeys` and `drizzle:SQLiteInlineForeignKeys`. Matching the
+     * suffix rather than listing the three keeps new dialects working without a change here.
+     * SingleStore has no entry because it does not support foreign keys at all, which is why
+     * `.references()` is not even a function there.
+     */
+    private inlineForeignKeys;
+    /**
+     * Normalise one foreign key, inline or table-level, into a common shape.
+     *
+     * `.reference()` yields the resolved columns on both. The referential actions do not live
+     * in the same place: a built ForeignKey exposes `onDelete`/`onUpdate` as strings, while an
+     * unbuilt ForeignKeyBuilder exposes them as the chainable setter functions and keeps the
+     * values in `_onDelete`/`_onUpdate`. Reading the wrong one yields a function where a string
+     * is expected, so check the type rather than the property's presence.
+     *
+     * Postgres reports 'no action' where MySQL and SQLite report nothing, for identical schemas.
+     * Since 'no action' *is* the default, it is normalised away so the same schema analyses the
+     * same across dialects.
+     */
+    private readForeignKey;
+    /**
+     * Render a Drizzle SQL template back into readable text.
+     *
+     * A `sql` tagged template is stored as alternating chunks: literal fragments holding a
+     * string array, and column references. `String()` on that array yields "[object Object]",
+     * so a check constraint's expression has to be assembled rather than stringified.
+     * Anything unrecognised becomes `?`, which is honest about the gap without inventing SQL.
+     */
+    private renderSql;
+    /** A value produced by Drizzle's `relations()` helper: a source table plus a callback. */
+    private isRelationsObject;
+    /**
+     * Read the relations declared by `relations(table, ({ one, many }) => ...)`.
+     *
+     * The previous implementation looked for `val.config.relations`. That property does not
+     * exist: `config` is a *function*, so the expression was always undefined and the branch
+     * never ran. Nothing failed loudly, relations simply came back empty forever.
+     *
+     * `config` cannot just be read, it has to be invoked with the builder Drizzle would pass.
+     * Rather than depend on drizzle-orm to obtain the real builder, which this package
+     * deliberately does not do anywhere else, a stand-in supplies the only two functions a
+     * user's callback can call. `relations()` wraps that callback and calls `.withFieldName()`
+     * on each returned value, so the stand-in results must carry that method or the call throws.
+     */
+    private readRelationsObject;
+    /**
+     * Infer many-to-many links through a join table.
+     *
+     * A join table is taken to be one whose every column participates in a foreign key, and
+     * which points at exactly two distinct tables. Requiring *all* columns to be foreign keys
+     * is deliberate: a table carrying its own data is a real entity, not plumbing, and calling
+     * it a join table would invent a relation the author never declared.
+     */
+    private inferManyToMany;
     private mapColumnType;
     private analyzeTable;
     analyze(opts?: AnalyzeOptions): Promise<Analysis>;
 }
 
-export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type Dialect, type Enum, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default };
+export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type Dialect, type Enum, type ForeignKey, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default };

package/dist/index.d.ts

@@ -44,6 +44,21 @@ interface Check {
     name?: string;
     expression?: string;
 }
+/**
+ * A foreign key as declared, which may span several columns. Single-column keys are also
+ * mirrored onto `Column.references` for convenience; composite ones exist only here, because
+ * they cannot be attributed to any one column.
+ *
+ * Column names are TypeScript property names, matching `Column.name`.
+ */
+interface ForeignKey {
+    name?: string;
+    columns: string[];
+    foreignTable: string;
+    foreignColumns: string[];
+    onDelete?: string;
+    onUpdate?: string;
+}
 interface Table {
     name: string;
     tsName: string;
@@ -53,6 +68,7 @@ interface Table {
     unique: Key[];
     indexes: Index[];
     checks?: Check[];
+    foreignKeys?: ForeignKey[];
     meta?: Record<string, unknown>;
 }
 interface Enum {
@@ -76,9 +92,88 @@ declare class SchemaAnalyzer {
     private readonly schemaPath;
     constructor(schemaPath: string);
     private getSymbol;
+    /**
+     * Drizzle keys the Columns object by TypeScript property name, but every other piece of
+     * metadata (foreign keys, indexes, composite primary keys) reports the *database* column
+     * name. We report the TS name, since that is what a generated schema has to spell, so
+     * anything coming from that other metadata has to be translated back.
+     *
+     * Falls through to the input when a name is unknown, which keeps raw SQL expressions and
+     * columns belonging to another table readable rather than dropping them.
+     */
+    private dbToTsNames;
+    /**
+     * Entries from a table's third argument, the extra-config callback.
+     *
+     * Drizzle invokes this callback with the table's ExtraConfigColumns, NOT with the table.
+     * Passing the table throws, and because the whole block used to sit under a bare `catch {}`
+     * the throw was swallowed and every index, unique index, composite primary key, check
+     * constraint and table-level foreign key silently vanished from the analysis.
+     *
+     * Both shapes are accepted: modern Drizzle returns an array, older versions an object.
+     */
+    private extraConfigEntries;
+    /**
+     * Foreign keys declared inline with `.references()`.
+     *
+     * Drizzle stores these per dialect under `drizzle:PgInlineForeignKeys`,
+     * `drizzle:MySqlInlineForeignKeys` and `drizzle:SQLiteInlineForeignKeys`. Matching the
+     * suffix rather than listing the three keeps new dialects working without a change here.
+     * SingleStore has no entry because it does not support foreign keys at all, which is why
+     * `.references()` is not even a function there.
+     */
+    private inlineForeignKeys;
+    /**
+     * Normalise one foreign key, inline or table-level, into a common shape.
+     *
+     * `.reference()` yields the resolved columns on both. The referential actions do not live
+     * in the same place: a built ForeignKey exposes `onDelete`/`onUpdate` as strings, while an
+     * unbuilt ForeignKeyBuilder exposes them as the chainable setter functions and keeps the
+     * values in `_onDelete`/`_onUpdate`. Reading the wrong one yields a function where a string
+     * is expected, so check the type rather than the property's presence.
+     *
+     * Postgres reports 'no action' where MySQL and SQLite report nothing, for identical schemas.
+     * Since 'no action' *is* the default, it is normalised away so the same schema analyses the
+     * same across dialects.
+     */
+    private readForeignKey;
+    /**
+     * Render a Drizzle SQL template back into readable text.
+     *
+     * A `sql` tagged template is stored as alternating chunks: literal fragments holding a
+     * string array, and column references. `String()` on that array yields "[object Object]",
+     * so a check constraint's expression has to be assembled rather than stringified.
+     * Anything unrecognised becomes `?`, which is honest about the gap without inventing SQL.
+     */
+    private renderSql;
+    /** A value produced by Drizzle's `relations()` helper: a source table plus a callback. */
+    private isRelationsObject;
+    /**
+     * Read the relations declared by `relations(table, ({ one, many }) => ...)`.
+     *
+     * The previous implementation looked for `val.config.relations`. That property does not
+     * exist: `config` is a *function*, so the expression was always undefined and the branch
+     * never ran. Nothing failed loudly, relations simply came back empty forever.
+     *
+     * `config` cannot just be read, it has to be invoked with the builder Drizzle would pass.
+     * Rather than depend on drizzle-orm to obtain the real builder, which this package
+     * deliberately does not do anywhere else, a stand-in supplies the only two functions a
+     * user's callback can call. `relations()` wraps that callback and calls `.withFieldName()`
+     * on each returned value, so the stand-in results must carry that method or the call throws.
+     */
+    private readRelationsObject;
+    /**
+     * Infer many-to-many links through a join table.
+     *
+     * A join table is taken to be one whose every column participates in a foreign key, and
+     * which points at exactly two distinct tables. Requiring *all* columns to be foreign keys
+     * is deliberate: a table carrying its own data is a real entity, not plumbing, and calling
+     * it a join table would invent a relation the author never declared.
+     */
+    private inferManyToMany;
     private mapColumnType;
     private analyzeTable;
     analyze(opts?: AnalyzeOptions): Promise<Analysis>;
 }
 
-export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type Dialect, type Enum, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default };
+export { type Analysis, type AnalyzeOptions, type Check, type Column, type ColumnRef, type Dialect, type Enum, type ForeignKey, type Index, type Issue, type Key, type Relation, SchemaAnalyzer, type Table, SchemaAnalyzer as default };

package/dist/index.js

@@ -16,6 +16,197 @@ var SchemaAnalyzer = class {
     }
     return table[Symbol.for(key)];
   }
+  /**
+   * Drizzle keys the Columns object by TypeScript property name, but every other piece of
+   * metadata (foreign keys, indexes, composite primary keys) reports the *database* column
+   * name. We report the TS name, since that is what a generated schema has to spell, so
+   * anything coming from that other metadata has to be translated back.
+   *
+   * Falls through to the input when a name is unknown, which keeps raw SQL expressions and
+   * columns belonging to another table readable rather than dropping them.
+   */
+  dbToTsNames(columnsObj) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [tsName, col] of Object.entries(columnsObj ?? {})) {
+      const dbName = col?.name;
+      if (typeof dbName === "string") map.set(dbName, tsName);
+    }
+    return (dbName) => {
+      const raw = typeof dbName === "string" ? dbName : dbName?.name ?? String(dbName);
+      return map.get(raw) ?? raw;
+    };
+  }
+  /**
+   * Entries from a table's third argument, the extra-config callback.
+   *
+   * Drizzle invokes this callback with the table's ExtraConfigColumns, NOT with the table.
+   * Passing the table throws, and because the whole block used to sit under a bare `catch {}`
+   * the throw was swallowed and every index, unique index, composite primary key, check
+   * constraint and table-level foreign key silently vanished from the analysis.
+   *
+   * Both shapes are accepted: modern Drizzle returns an array, older versions an object.
+   */
+  extraConfigEntries(tbl, issues, tableName) {
+    const builder = this.getSymbol(tbl, "drizzle:ExtraConfigBuilder");
+    if (typeof builder !== "function") return [];
+    const cols = this.getSymbol(tbl, "drizzle:ExtraConfigColumns") ?? tbl;
+    try {
+      const built = builder(cols);
+      if (!built) return [];
+      return Array.isArray(built) ? built : Object.values(built);
+    } catch (e) {
+      issues.push({
+        code: "DRZL_ANL_EXTRACONFIG",
+        level: "warn",
+        message: `Could not evaluate the extra-config callback for table "${tableName}": ${e.message}`,
+        hint: "Indexes, composite keys, checks and table-level foreign keys will be missing for this table."
+      });
+      return [];
+    }
+  }
+  /**
+   * Foreign keys declared inline with `.references()`.
+   *
+   * Drizzle stores these per dialect under `drizzle:PgInlineForeignKeys`,
+   * `drizzle:MySqlInlineForeignKeys` and `drizzle:SQLiteInlineForeignKeys`. Matching the
+   * suffix rather than listing the three keeps new dialects working without a change here.
+   * SingleStore has no entry because it does not support foreign keys at all, which is why
+   * `.references()` is not even a function there.
+   */
+  inlineForeignKeys(tbl) {
+    try {
+      for (const s of Object.getOwnPropertySymbols(tbl)) {
+        if (/InlineForeignKeys$/.test(s.description ?? "")) {
+          const v = tbl[s];
+          if (Array.isArray(v)) return v;
+        }
+      }
+    } catch {
+    }
+    return [];
+  }
+  /**
+   * Normalise one foreign key, inline or table-level, into a common shape.
+   *
+   * `.reference()` yields the resolved columns on both. The referential actions do not live
+   * in the same place: a built ForeignKey exposes `onDelete`/`onUpdate` as strings, while an
+   * unbuilt ForeignKeyBuilder exposes them as the chainable setter functions and keeps the
+   * values in `_onDelete`/`_onUpdate`. Reading the wrong one yields a function where a string
+   * is expected, so check the type rather than the property's presence.
+   *
+   * Postgres reports 'no action' where MySQL and SQLite report nothing, for identical schemas.
+   * Since 'no action' *is* the default, it is normalised away so the same schema analyses the
+   * same across dialects.
+   */
+  readForeignKey(fk, toTs) {
+    let ref;
+    try {
+      ref = fk?.reference?.();
+    } catch {
+      return void 0;
+    }
+    if (!ref?.foreignTable) return void 0;
+    const action = (v, fallback) => {
+      const raw = typeof v === "string" ? v : typeof fallback === "string" ? fallback : void 0;
+      return raw && raw.toLowerCase() !== "no action" ? raw : void 0;
+    };
+    const foreignColumnsObj = this.getSymbol(ref.foreignTable, "drizzle:Columns") ?? {};
+    const toForeignTs = this.dbToTsNames(foreignColumnsObj);
+    return {
+      columns: (ref.columns ?? []).map((c) => toTs(c?.name)),
+      foreignTable: this.getSymbol(ref.foreignTable, "drizzle:Name") ?? "unknown",
+      foreignColumns: (ref.foreignColumns ?? []).map((c) => toForeignTs(c?.name)),
+      onDelete: action(fk?.onDelete, fk?._onDelete),
+      onUpdate: action(fk?.onUpdate, fk?._onUpdate),
+      name: typeof fk?.getName === "function" ? void 0 : fk?.name
+    };
+  }
+  /**
+   * Render a Drizzle SQL template back into readable text.
+   *
+   * A `sql` tagged template is stored as alternating chunks: literal fragments holding a
+   * string array, and column references. `String()` on that array yields "[object Object]",
+   * so a check constraint's expression has to be assembled rather than stringified.
+   * Anything unrecognised becomes `?`, which is honest about the gap without inventing SQL.
+   */
+  renderSql(value, toTs) {
+    const chunks = value?.queryChunks;
+    if (!Array.isArray(chunks)) return String(value ?? "");
+    return chunks.map((c) => {
+      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);
+      return "?";
+    }).join("").trim();
+  }
+  /** A value produced by Drizzle's `relations()` helper: a source table plus a callback. */
+  isRelationsObject(val) {
+    return !!val && typeof val === "object" && typeof val.config === "function" && !!this.getSymbol(val.table, "drizzle:Columns");
+  }
+  /**
+   * Read the relations declared by `relations(table, ({ one, many }) => ...)`.
+   *
+   * The previous implementation looked for `val.config.relations`. That property does not
+   * exist: `config` is a *function*, so the expression was always undefined and the branch
+   * never ran. Nothing failed loudly, relations simply came back empty forever.
+   *
+   * `config` cannot just be read, it has to be invoked with the builder Drizzle would pass.
+   * Rather than depend on drizzle-orm to obtain the real builder, which this package
+   * deliberately does not do anywhere else, a stand-in supplies the only two functions a
+   * user's callback can call. `relations()` wraps that callback and calls `.withFieldName()`
+   * 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 make = (kind) => (table, cfg) => ({
+      kind,
+      referencedTable: table,
+      cfg,
+      withFieldName(n) {
+        this.fieldName = n;
+        return this;
+      }
+    });
+    try {
+      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");
+        if (to) out.push({ kind: rel.kind, from, to });
+      }
+      return out;
+    } catch (e) {
+      issues.push({
+        code: "DRZL_ANL_RELATIONS",
+        level: "warn",
+        message: `Could not read the relations declared in "${exportName}": ${e.message}`,
+        hint: "Relations for this table will be missing from the analysis."
+      });
+      return [];
+    }
+  }
+  /**
+   * Infer many-to-many links through a join table.
+   *
+   * A join table is taken to be one whose every column participates in a foreign key, and
+   * which points at exactly two distinct tables. Requiring *all* columns to be foreign keys
+   * is deliberate: a table carrying its own data is a real entity, not plumbing, and calling
+   * it a join table would invent a relation the author never declared.
+   */
+  inferManyToMany(tables) {
+    const out = [];
+    for (const t of tables) {
+      const fks = t.foreignKeys ?? [];
+      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))];
+      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 });
+    }
+    return out;
+  }
   mapColumnType(column) {
     const ctor = column?.constructor?.name ?? "";
     switch (ctor) {
@@ -31,14 +222,17 @@ var SchemaAnalyzer = class {
       case "SQLiteBlob":
         return { tsType: "Uint8Array", dbType: "BLOB" };
       case "SQLiteNumeric":
-        return { tsType: "number", dbType: "NUMERIC" };
+        return { tsType: "string", dbType: "NUMERIC" };
       case "SQLiteBoolean":
         return { tsType: "boolean", dbType: "INTEGER" };
       case "PgInteger":
       case "PgSmallInt":
         return { tsType: "number", dbType: "INTEGER" };
       case "PgBigInt":
-        return { tsType: "bigint", dbType: "BIGINT" };
+        return {
+          tsType: column?.config?.mode === "number" ? "number" : "bigint",
+          dbType: "BIGINT"
+        };
       case "PgSerial":
       case "PgSmallSerial":
       case "PgBigSerial":
@@ -56,9 +250,10 @@ var SchemaAnalyzer = class {
       case "PgDate":
         return { tsType: "Date", dbType: "TIMESTAMP" };
       case "PgNumeric":
+        return { tsType: "string", dbType: "NUMERIC" };
       case "PgFloat":
       case "PgDoublePrecision":
-        return { tsType: "number", dbType: "NUMERIC" };
+        return { tsType: "number", dbType: "DOUBLE" };
       case "PgJson":
       case "PgJsonb":
         return { tsType: "any", dbType: ctor === "PgJsonb" ? "JSONB" : "JSON" };
@@ -137,12 +332,13 @@ var SchemaAnalyzer = class {
         return { tsType: "unknown", dbType: "UNKNOWN" };
     }
   }
-  analyzeTable(tsName, tbl) {
+  analyzeTable(tsName, tbl, issues = []) {
     const columnsObj = this.getSymbol(tbl, "drizzle:Columns") ?? {};
     const columns = [];
     const unique = [];
     const indexes = [];
     const checks = [];
+    const foreignKeys = [];
     const pkCols = [];
     const uniqueGroups = /* @__PURE__ */ new Map();
     for (const [colName, col] of Object.entries(columnsObj)) {
@@ -155,13 +351,7 @@ var SchemaAnalyzer = class {
       const nullable = !col?.notNull && !col?.config?.notNull;
       const isGenerated = !!(col?.autoIncrement || col?.isGenerated);
       const hasDefault = col?.default !== void 0 || col?.config?.default !== void 0 || isGenerated;
-      const ref = col?.references;
-      const references = ref ? {
-        table: ref.table ?? "unknown",
-        column: ref.column ?? "id",
-        onDelete: ref.onDelete,
-        onUpdate: ref.onUpdate
-      } : void 0;
+      const references = void 0;
       const isUnique = !!(col?.isUnique || col?.config?.isUnique);
       const isPk = !!(col?.primary || col?.config?.primaryKey);
       if (isPk) pkCols.push(colName);
@@ -186,10 +376,11 @@ var SchemaAnalyzer = class {
     }
     const name = this.getSymbol(tbl, "drizzle:Name") || tsName;
     const schema = this.getSymbol(tbl, "drizzle:Schema");
+    const toTs = this.dbToTsNames(columnsObj);
     try {
-      const pkDef = tbl[Symbol.for("drizzle:PrimaryKey")];
+      const pkDef = this.getSymbol(tbl, "drizzle:PrimaryKey");
       if (pkDef && Array.isArray(pkDef.columns)) {
-        const cols = pkDef.columns.map((c) => c?.name ?? String(c)).filter(Boolean);
+        const cols = pkDef.columns.map((c) => toTs(c?.name)).filter(Boolean);
         if (cols.length) {
           pkCols.splice(0, pkCols.length, ...cols);
         }
@@ -197,36 +388,50 @@ var SchemaAnalyzer = class {
     } catch {
     }
     try {
-      const idxDef = tbl[Symbol.for("drizzle:Indexes")];
+      const idxDef = this.getSymbol(tbl, "drizzle:Indexes");
       if (Array.isArray(idxDef)) {
         for (const i of idxDef) {
-          const cols = (i?.columns ?? []).map((c) => c?.name ?? String(c)).filter(Boolean);
+          const cols = (i?.columns ?? []).map((c) => toTs(c?.name)).filter(Boolean);
           if (cols.length) indexes.push({ columns: cols, name: i?.name });
           if (i?.unique && cols.length) unique.push({ columns: cols });
         }
       }
     } catch {
     }
-    try {
-      const builder = tbl[Symbol.for("drizzle:ExtraConfigBuilder")];
-      if (typeof builder === "function") {
-        const built = builder(tbl);
-        const entries = Array.isArray(built) ? built.map((v, i) => [v?.config?.name ?? v?.name ?? `idx_${i}`, v]) : Object.entries(built ?? {});
-        for (const [key, val] of entries) {
-          const cfg = val?.config ?? val;
-          const cols = (cfg?.columns ?? []).map((c) => c?.name ?? String(c)).filter(Boolean);
-          const uniqueFlag = !!(cfg?.unique || /unique/i.test(val?.constructor?.name ?? "") || /unique/i.test(key));
-          const idxName = cfg?.name ?? val?.name ?? key;
-          const expr = cfg?.where || cfg?.expression;
-          if (expr && !cols.length) {
-            checks.push({ name: idxName, expression: String(expr) });
-          } else if (cols.length) {
-            indexes.push({ columns: cols, name: idxName });
-            if (uniqueFlag) unique.push({ columns: cols });
-          }
-        }
+    for (const entry of this.extraConfigEntries(tbl, issues, name)) {
+      if (typeof entry?.reference === "function") {
+        const fk = this.readForeignKey(entry, toTs);
+        if (fk) foreignKeys.push(fk);
+        continue;
       }
-    } catch {
+      if (entry?.value?.queryChunks && entry?.name !== void 0) {
+        checks.push({ name: entry.name, expression: this.renderSql(entry.value, toTs) });
+        continue;
+      }
+      const cfg = entry?.config ?? entry ?? {};
+      const cols = (cfg.columns ?? []).map((c) => toTs(c?.name)).filter(Boolean);
+      if (!cols.length) continue;
+      if (cfg.unique === void 0) {
+        pkCols.splice(0, pkCols.length, ...cols);
+        continue;
+      }
+      indexes.push({ columns: cols, name: cfg.name });
+      if (cfg.unique) unique.push({ columns: cols, name: cfg.name });
+    }
+    for (const fk of this.inlineForeignKeys(tbl)) {
+      const read = this.readForeignKey(fk, toTs);
+      if (read) foreignKeys.push(read);
+    }
+    for (const fk of foreignKeys) {
+      if (fk.columns.length !== 1 || fk.foreignColumns.length !== 1) continue;
+      const col = columns.find((c) => c.name === fk.columns[0]);
+      if (!col) continue;
+      col.references = {
+        table: fk.foreignTable,
+        column: fk.foreignColumns[0],
+        onDelete: fk.onDelete,
+        onUpdate: fk.onUpdate
+      };
     }
     return {
       name,
@@ -240,6 +445,7 @@ var SchemaAnalyzer = class {
       ],
       indexes: [...pkCols.length ? [{ columns: pkCols }] : [], ...indexes],
       checks,
+      foreignKeys,
       meta: {}
     };
   }
@@ -275,39 +481,29 @@ var SchemaAnalyzer = class {
     const tables = [];
     const relations = [];
     const enums = [];
+    const columnEnums = [];
     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);
+          const table = this.analyzeTable(name, val, issues);
           tables.push(table);
-          if (opts.includeRelations) {
-            for (const col of table.columns) {
-              if (col.references) {
-                relations.push({
-                  kind: "many",
-                  from: table.name,
-                  to: col.references.table
-                });
-              }
-              const enumVals = cols[col.name]?.enumValues;
-              if (enumVals && enumVals.length) {
-                const enumName = `${table.name}_${col.name}_enum`;
-                if (!enums.find((e) => e.name === enumName))
-                  enums.push({ name: enumName, values: enumVals });
-              }
+          for (const col of table.columns) {
+            const enumVals = cols[col.name]?.enumValues;
+            if (enumVals && enumVals.length) {
+              columnEnums.push({ name: `${table.name}_${col.name}_enum`, values: enumVals });
             }
           }
-        } else if (val?.config?.relations) {
-          const cfg = val.config.relations;
-          const base = name.replace(/Relations$/, "");
-          for (const entry of Object.values(cfg)) {
-            const target = entry?.referencedTable;
-            const targetName = target ? this.getSymbol(target, "drizzle:Name") : void 0;
-            if (targetName) {
-              relations.push({ kind: "many", from: base, to: targetName });
+          if (opts.includeRelations) {
+            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 });
             }
           }
+        } else if (this.isRelationsObject(val)) {
+          if (opts.includeRelations) {
+            relations.push(...this.readRelationsObject(val, name, issues));
+          }
         } else {
           const ev = val?.enumValues;
           if (Array.isArray(ev) && ev.every((x) => typeof x === "string")) {
@@ -329,6 +525,12 @@ var SchemaAnalyzer = class {
         });
       }
     }
+    for (const candidate of columnEnums) {
+      const key = JSON.stringify(candidate.values);
+      if (enums.some((e) => JSON.stringify(e.values) === key)) continue;
+      if (enums.some((e) => e.name === candidate.name)) continue;
+      enums.push(candidate);
+    }
     let dialect = "unknown";
     const ctorNames = /* @__PURE__ */ new Set();
     for (const [_, val] of Object.entries(exportsObj)) {
@@ -352,6 +554,9 @@ var SchemaAnalyzer = class {
       );
       if (looksSqlite) dialect = "sqlite";
     }
+    if (opts.includeRelations) {
+      relations.push(...this.inferManyToMany(tables));
+    }
     if (opts.includeRelations && opts.includeHeuristicRelations) {
       const tableNames = new Set(tables.map((t) => t.name));
       const findTarget = (base) => {
@@ -362,19 +567,27 @@ var SchemaAnalyzer = class {
       };
       for (const t of tables) {
         for (const c of t.columns) {
+          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: "many", from: t.name, to: target });
+            if (target) relations.push({ kind: "one", from: t.name, to: target });
           }
         }
       }
     }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = relations.filter((r) => {
+      const key = `${r.kind}|${r.from}|${r.to}|${r.via ?? ""}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
     return {
       dialect,
       tables,
       enums,
-      relations,
+      relations: deduped,
       issues
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/analyzer",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -21,6 +21,7 @@
     "jiti": "^2.5.1"
   },
   "devDependencies": {
+    "drizzle-orm": "^0.45.2",
     "tsup": "^8.5.0",
     "typescript": "^5.9.2"
   },