drizzle-docs-generator 0.2.0 → 0.4.0

package/dist/generator/common.js

@@ -1,59 +1,26 @@
-import { is as m, Relation as j, getTableName as g, getTableColumns as d, One as b } from "drizzle-orm";
-import { PgTable as C, getTableConfig as v } from "drizzle-orm/pg-core";
-import { MySqlTable as T, getTableConfig as N } from "drizzle-orm/mysql-core";
-import { SQLiteTable as R, getTableConfig as K } from "drizzle-orm/sqlite-core";
-import { mkdirSync as q, writeFileSync as V } from "node:fs";
-import { resolve as O, dirname as x } from "node:path";
-import { extractComments as S } from "../parser/comments.js";
-import { extractRelations as k } from "../parser/relations.js";
-class D {
-  lines = [];
-  indentLevel = 0;
-  /**
-   * Increase the indentation level by one
-   * @returns This instance for method chaining
-   */
-  indent() {
-    return this.indentLevel++, this;
-  }
-  /**
-   * Decrease the indentation level by one (minimum 0)
-   * @returns This instance for method chaining
-   */
-  dedent() {
-    return this.indentLevel = Math.max(0, this.indentLevel - 1), this;
-  }
-  /**
-   * Add a line with the current indentation level
-   * @param content - The content to add (empty string adds a blank line)
-   * @returns This instance for method chaining
-   */
-  line(e = "") {
-    const t = "  ".repeat(this.indentLevel);
-    return this.lines.push(e ? `${t}${e}` : ""), this;
-  }
-  /**
-   * Build the final DBML string from all added lines
-   * @returns The complete DBML content as a string
-   */
-  build() {
-    return this.lines.join(`
-`);
-  }
-}
-class B {
+import { is as r, Relation as h, getTableName as m, getTableColumns as y } from "drizzle-orm";
+import { PgTable as c, getTableConfig as b } from "drizzle-orm/pg-core";
+import { MySqlTable as f, getTableConfig as d } from "drizzle-orm/mysql-core";
+import { SQLiteTable as u, getTableConfig as T } from "drizzle-orm/sqlite-core";
+import { mkdirSync as C, writeFileSync as D } from "node:fs";
+import { resolve as R, dirname as q } from "node:path";
+import { DbmlFormatter as j } from "../formatter/dbml.js";
+import { extractComments as v } from "../parser/comments.js";
+import { extractRelations as V } from "../parser/relations.js";
+import { V0RelationAdapter as x } from "../adapter/v0-adapter.js";
+import { V1RelationAdapter as K } from "../adapter/v1-adapter.js";
+class N {
   schema;
-  relational;
   generatedRefs = [];
   comments;
   parsedRelations;
   source;
   /**
    * Create a new generator instance
-   * @param options - Configuration options including schema, relational mode, source code, and comments
+   * @param options - Configuration options including schema, source code, and comments
    */
   constructor(e) {
-    this.schema = e.schema, this.relational = e.relational ?? !1, this.source = e.source, e.comments ? this.comments = e.comments : this.source && (this.comments = S(this.source)), this.relational && this.source && (this.parsedRelations = k(this.source));
+    this.schema = e.schema, this.source = e.source, e.comments ? this.comments = e.comments : this.source && (this.comments = v(this.source)), this.source && (this.parsedRelations = V(this.source));
   }
   /**
    * Generate complete DBML output from the schema
@@ -66,13 +33,8 @@ class B {
    * @returns The complete DBML string
    */
   generate() {
-    const e = new D(), t = this.getTables(), n = this.getV0Relations(), s = this.getV1RelationEntries();
-    for (const o of t)
-      this.generateTable(e, o), e.line();
-    this.relational && (s.length > 0 ? this.generateRelationalRefsFromV1(s) : (n.length > 0 || this.parsedRelations) && this.generateRelationalRefsFromV0());
-    for (const o of this.generatedRefs)
-      this.generateRef(e, o);
-    return e.build().trim();
+    const e = this.toIntermediateSchema();
+    return new j().format(e);
   }
   /**
    * Get all tables from schema
@@ -98,32 +60,7 @@ class B {
    * @returns True if value is a Drizzle table
    */
   isTable(e) {
-    return m(e, C) || m(e, T) || m(e, R);
-  }
-  /**
-   * Get all v0 relations from schema (legacy relations() API)
-   *
-   * Extracts legacy relations defined using the old relations() API.
-   * These are identified by having 'table' and 'config' properties.
-   *
-   * @returns Array of legacy relation objects
-   */
-  getV0Relations() {
-    const e = [];
-    for (const t of Object.values(this.schema))
-      this.isV0Relations(t) && e.push(t);
-    return e;
-  }
-  /**
-   * Check if a value is a Drizzle v0 relations object (from relations())
-   *
-   * Validates the legacy relations() format by checking for 'table' and 'config' properties.
-   *
-   * @param value - The value to check
-   * @returns True if value is a legacy relations object
-   */
-  isV0Relations(e) {
-    return typeof e != "object" || e === null ? !1 : "table" in e && "config" in e && typeof e.config == "object";
+    return r(e, c) || r(e, f) || r(e, u);
   }
   /**
    * Check if a value is a v1 relation entry (from defineRelations())
@@ -140,8 +77,8 @@ class B {
     const t = e;
     if (!("table" in t) || !("name" in t) || typeof t.name != "string" || !("relations" in t) || typeof t.relations != "object" || t.relations === null)
       return !1;
-    const n = t.relations, s = Object.values(n);
-    return s.length > 0 ? s.some((o) => m(o, j)) : this.isTable(t.table);
+    const n = t.relations, o = Object.values(n);
+    return o.length > 0 ? o.some((s) => r(s, h)) : this.isTable(t.table);
   }
   /**
    * Get all v1 relation entries from schema (defineRelations() API)
@@ -174,26 +111,7 @@ class B {
     if (typeof e != "object" || e === null || Array.isArray(e))
       return !1;
     const n = Object.values(e);
-    return n.length > 0 && n.every((s) => this.isV1RelationEntry(s));
-  }
-  /**
-   * Generate a table definition in DBML format
-   *
-   * Creates the complete table definition including columns, indexes, constraints,
-   * and table-level comments. Also collects foreign keys if not in relational mode.
-   *
-   * @param dbml - The DBML builder to add the table to
-   * @param table - The Drizzle table to generate
-   */
-  generateTable(e, t) {
-    const n = g(t), s = d(t), o = this.dialectConfig.escapeName(n);
-    e.line(`Table ${o} {`), e.indent();
-    for (const a of Object.values(s))
-      this.generateColumn(e, a, n);
-    const i = this.getTableConfig(t);
-    i && this.generateIndexesBlock(e, i);
-    const r = this.comments?.tables[n]?.comment;
-    r && (e.line(), e.line(`Note: '${$(r)}'`)), e.dedent(), e.line("}"), !this.relational && i && i.foreignKeys.length > 0 && this.collectForeignKeysFromConfig(n, i.foreignKeys);
+    return n.length > 0 && n.every((o) => this.isV1RelationEntry(o));
   }
   /**
    * Get table configuration from a Drizzle table
@@ -205,85 +123,51 @@ class B {
    * @returns Table configuration or undefined if dialect is not supported
    */
   getTableConfig(e) {
-    if (m(e, C)) {
-      const t = v(e);
-      return {
-        indexes: t.indexes || [],
-        primaryKeys: t.primaryKeys || [],
-        uniqueConstraints: t.uniqueConstraints || [],
-        foreignKeys: t.foreignKeys || []
-      };
-    }
-    if (m(e, T)) {
-      const t = N(e);
-      return {
-        indexes: t.indexes || [],
-        primaryKeys: t.primaryKeys || [],
-        uniqueConstraints: t.uniqueConstraints || [],
-        foreignKeys: t.foreignKeys || []
-      };
+    if (r(e, c)) {
+      const t = b(e);
+      return this.mapTableConfig(t);
     }
-    if (m(e, R)) {
-      const t = K(e);
-      return {
-        indexes: t.indexes || [],
-        primaryKeys: t.primaryKeys || [],
-        uniqueConstraints: t.uniqueConstraints || [],
-        foreignKeys: t.foreignKeys || []
-      };
+    if (r(e, f)) {
+      const t = d(e);
+      return this.mapTableConfig(t);
     }
-  }
-  /**
-   * Generate a column definition in DBML format
-   *
-   * Creates a column line with type and attributes (primary key, not null, unique, etc.)
-   * and includes column-level comments if available.
-   *
-   * @param dbml - The DBML builder to add the column to
-   * @param column - The Drizzle column to generate
-   * @param tableName - Optional table name for looking up comments
-   */
-  generateColumn(e, t, n) {
-    const s = this.dialectConfig.escapeName(t.name), o = this.getColumnType(t), i = this.getColumnAttributes(t, n), r = this.formatAttributes(i);
-    r ? e.line(`${s} ${o} [${r}]`) : e.line(`${s} ${o}`);
-  }
-  /**
-   * Get the SQL type for a column
-   *
-   * @param column - The column to get the SQL type from
-   * @returns The SQL type string (e.g., "varchar", "integer")
-   */
-  getColumnType(e) {
-    return e.getSQLType();
-  }
-  /**
-   * Get column attributes for DBML
-   *
-   * Extracts attributes like primary key, not null, unique, increment, default value,
-   * and note from the column. Uses column metadata and comments if available.
-   *
-   * @param column - The column to get attributes from
-   * @param tableName - Optional table name for looking up comments
-   * @returns Array of attribute strings for DBML format
-   */
-  getColumnAttributes(e, t) {
-    const n = [];
-    e.primary && n.push("primary key"), e.notNull && n.push("not null"), e.isUnique && n.push("unique"), this.dialectConfig.isIncrement(e) && n.push("increment");
-    const s = this.getDefaultValue(e);
-    if (s !== void 0 && n.push(`default: ${s}`), t) {
-      const o = this.comments?.tables[t]?.columns[e.name]?.comment;
-      o && n.push(`note: '${$(o)}'`);
+    if (r(e, u)) {
+      const t = T(e);
+      return this.mapTableConfig(t);
     }
-    return n;
   }
   /**
-   * Format attributes into a string
+   * Map Drizzle's internal table config to our typed TableConfig
    *
-   * @param attrs - Array of attribute strings
-   * @returns Comma-separated attribute string
+   * Note: Drizzle ORM's columns type is `SQL<unknown> | IndexedColumn` union,
+   * so we use `{ name?: string }` and cast to access the name property.
+   * This is unavoidable due to Drizzle's internal type structure.
    */
-  formatAttributes(e) {
-    return e.join(", ");
+  mapTableConfig(e) {
+    return {
+      indexes: (e.indexes || []).map((t) => ({
+        config: {
+          columns: t.config.columns.filter((n) => typeof n.name == "string").map((n) => ({ name: n.name })),
+          name: t.config.name,
+          unique: t.config.unique ?? !1,
+          using: t.config.using
+        }
+      })),
+      primaryKeys: (e.primaryKeys || []).map((t) => ({
+        columns: t.columns.filter((n) => typeof n.name == "string").map((n) => ({ name: n.name })),
+        name: t.name
+      })),
+      uniqueConstraints: (e.uniqueConstraints || []).map((t) => ({
+        columns: t.columns.filter((n) => typeof n.name == "string").map((n) => ({ name: n.name })),
+        name: t.name
+      })),
+      foreignKeys: (e.foreignKeys || []).map((t) => ({
+        reference: t.reference,
+        name: t.name,
+        onDelete: t.onDelete,
+        onUpdate: t.onUpdate
+      }))
+    };
   }
   /**
    * Get the default value for a column
@@ -303,58 +187,19 @@ class B {
     if (t !== void 0) {
       if (typeof t == "object" && t !== null) {
         if ("queryChunks" in t) {
-          const n = t.queryChunks, s = [];
-          for (const o of n)
-            typeof o == "string" ? s.push(o) : typeof o == "object" && o !== null && "value" in o && s.push(String(o.value));
-          return `\`${s.join("")}\``;
+          const n = t.queryChunks, o = [];
+          for (const s of n)
+            typeof s == "string" ? o.push(s) : typeof s == "object" && s !== null && "value" in s && o.push(String(s.value));
+          return o.join("");
         }
-        return "sql" in t ? `\`${t.sql}\`` : `'${JSON.stringify(t)}'`;
+        return "sql" in t ? t.sql : JSON.stringify(t);
       }
       if (typeof t == "string")
-        return `'${t.replace(/'/g, "\\'")}'`;
+        return `'${t.replace(/'/g, "''")}'`;
       if (typeof t == "number" || typeof t == "boolean")
         return String(t);
     }
   }
-  /**
-   * Generate indexes block from table configuration
-   *
-   * Creates the indexes block containing primary keys, unique constraints,
-   * and regular indexes with their respective attributes.
-   *
-   * @param dbml - The DBML builder to add the indexes block to
-   * @param tableConfig - The table configuration containing index information
-   */
-  generateIndexesBlock(e, t) {
-    const { indexes: n, primaryKeys: s, uniqueConstraints: o } = t;
-    if (!(n.length === 0 && s.length === 0 && o.length === 0)) {
-      e.line(), e.line("indexes {"), e.indent();
-      for (const i of s) {
-        const r = this.getPrimaryKeyColumns(i);
-        if (r.length > 0) {
-          const a = r.map((l) => this.dialectConfig.escapeName(l)).join(", ");
-          e.line(`(${a}) [pk]`);
-        }
-      }
-      for (const i of o) {
-        const r = this.getUniqueConstraintColumns(i);
-        if (r.length > 0) {
-          const a = r.map((l) => this.dialectConfig.escapeName(l)).join(", ");
-          e.line(`(${a}) [unique]`);
-        }
-      }
-      for (const i of n) {
-        const r = this.getIndexColumns(i);
-        if (r.length > 0) {
-          const a = r.map((h) => this.dialectConfig.escapeName(h)).join(", "), l = [];
-          this.isUniqueIndex(i) && l.push("unique");
-          const c = l.length > 0 ? ` [${l.join(", ")}]` : "";
-          e.line(`(${a})${c}`);
-        }
-      }
-      e.dedent(), e.line("}");
-    }
-  }
   /**
    * Collect foreign keys from table configuration
    *
@@ -366,8 +211,8 @@ class B {
    */
   collectForeignKeysFromConfig(e, t) {
     for (const n of t) {
-      const s = this.parseForeignKey(e, n);
-      s && this.generatedRefs.push(s);
+      const o = this.parseForeignKey(e, n);
+      this.generatedRefs.push(o);
     }
   }
   /**
@@ -378,322 +223,258 @@ class B {
    *
    * @param tableName - The name of the source table
    * @param fk - The foreign key definition to parse
-   * @returns GeneratedRef object or undefined if parsing fails
+   * @returns GeneratedRef object
    */
   parseForeignKey(e, t) {
-    try {
-      const n = t, s = n.reference(), o = s.columns.map((a) => a.name), i = s.foreignColumns.map((a) => a.name), r = g(s.foreignTable);
-      return {
-        fromTable: e,
-        fromColumns: o,
-        toTable: r,
-        toColumns: i,
-        type: ">",
-        onDelete: n.onDelete,
-        onUpdate: n.onUpdate
-      };
-    } catch {
-      return;
-    }
-  }
-  /**
-   * Get a mapping from variable names to table names in the schema
-   *
-   * Creates a map from TypeScript variable names (e.g., "usersTable") to
-   * actual database table names (e.g., "users").
-   *
-   * @returns Map of variable names to table names
-   */
-  getTableNameMapping() {
-    const e = /* @__PURE__ */ new Map();
-    for (const [t, n] of Object.entries(this.schema))
-      if (this.isTable(n)) {
-        const s = g(n);
-        e.set(t, s);
-      }
-    return e;
+    const n = t.reference(), o = n.columns.map((a) => a.name), s = n.foreignColumns.map((a) => a.name), i = m(n.foreignTable);
+    return {
+      fromTable: e,
+      fromColumns: o,
+      toTable: i,
+      toColumns: s,
+      type: ">",
+      onDelete: t.onDelete,
+      onUpdate: t.onUpdate
+    };
   }
   /**
-   * Get a mapping from TypeScript property names to database column names for a table
+   * Detect if relation definitions are present in the schema
    *
-   * Creates a map from TypeScript property names (e.g., "authorId") to
-   * actual database column names (e.g., "author_id").
+   * Checks for both v1 (defineRelations()) and v0 (relations()) API usage.
+   * Returns true if any relation definitions are found.
    *
-   * @param tableVarName - The variable name of the table in the schema
-   * @returns Map of property names to column names
+   * @returns True if relations are defined, false otherwise
    */
-  getColumnNameMapping(e) {
-    const t = /* @__PURE__ */ new Map(), n = this.schema[e];
-    if (n && this.isTable(n)) {
-      const s = d(n);
-      for (const [o, i] of Object.entries(s))
-        t.set(o, i.name);
-    }
-    return t;
+  hasRelationDefinitions() {
+    return !!(this.getV1RelationEntries().length > 0 || this.parsedRelations && this.parsedRelations.relations.length > 0);
   }
   /**
-   * Check if there's a reverse one() relation (B->A when we have A->B)
+   * Create the appropriate relation adapter based on schema contents
    *
-   * Used to detect one-to-one relationships by checking if both tables
-   * have one() relations pointing to each other.
+   * Detects whether v1 or v0 relations are present and returns the
+   * corresponding adapter implementation.
    *
-   * @param sourceTable - The source table variable name
-   * @param targetTable - The target table variable name
-   * @param sourceFields - The source table's field names
-   * @param targetReferences - The target table's reference column names
-   * @returns True if a reverse one() relation exists
+   * @returns RelationAdapter instance (V1RelationAdapter or V0RelationAdapter)
    */
-  hasReverseOneRelation(e, t, n, s) {
-    if (!this.parsedRelations) return !1;
-    for (const o of this.parsedRelations.relations)
-      if (o.type === "one" && o.sourceTable === t && o.targetTable === e && o.fields.length > 0 && o.references.length > 0) {
-        const i = o.fields, r = o.references;
-        if (this.arraysEqual(i, s) && this.arraysEqual(r, n))
-          return !0;
-      }
-    return !1;
+  createRelationAdapter() {
+    const e = this.getV1RelationEntries();
+    return e.length > 0 ? new K(e) : new x(this.schema, this.parsedRelations);
   }
   /**
-   * Helper to check if two arrays are equal
+   * Convert a UnifiedRelation to a RelationDefinition
    *
-   * @param a - First array
-   * @param b - Second array
-   * @returns True if arrays have same length and same elements in order
-   */
-  arraysEqual(e, t) {
-    return e.length !== t.length ? !1 : e.every((n, s) => n === t[s]);
-  }
-  /**
-   * Generate references from v0 relations() API
+   * Maps the unified relation format from adapters to the intermediate
+   * schema's RelationDefinition format.
    *
-   * Uses TypeScript Compiler API to parse relations() definitions from source file
-   * and extract fields/references to generate DBML Ref lines.
-   *
-   * Detects one-to-one relationships when bidirectional one() relations exist.
+   * @param unified - The unified relation from adapter
+   * @returns RelationDefinition for intermediate schema
    */
-  generateRelationalRefsFromV0() {
-    if (!this.parsedRelations || this.parsedRelations.relations.length === 0)
-      return;
-    const e = this.getTableNameMapping(), t = /* @__PURE__ */ new Set();
-    for (const n of this.parsedRelations.relations) {
-      if (n.type !== "one" || n.fields.length === 0 || n.references.length === 0)
-        continue;
-      const s = e.get(n.sourceTable), o = e.get(n.targetTable);
-      if (!s || !o)
-        continue;
-      const i = this.getColumnNameMapping(n.sourceTable), r = this.getColumnNameMapping(n.targetTable), a = n.fields.map(
-        (u) => i.get(u) || u
-      ), l = n.references.map((u) => r.get(u) || u), c = `${s}.${a.join(",")}-${o}.${l.join(",")}`, h = `${o}.${l.join(",")}-${s}.${a.join(",")}`;
-      if (t.has(c) || t.has(h))
-        continue;
-      t.add(c);
-      const f = this.hasReverseOneRelation(
-        n.sourceTable,
-        n.targetTable,
-        n.fields,
-        n.references
-      ), p = {
-        fromTable: s,
-        fromColumns: a,
-        toTable: o,
-        toColumns: l,
-        type: f ? "-" : ">"
-      };
-      this.generatedRefs.push(p);
-    }
+  unifiedRelationToDefinition(e) {
+    return {
+      fromTable: e.sourceTable,
+      fromColumns: e.sourceColumns,
+      toTable: e.targetTable,
+      toColumns: e.targetColumns,
+      type: e.relationType,
+      onDelete: e.onDelete,
+      onUpdate: e.onUpdate
+    };
   }
   /**
-   * Generate references from v1 defineRelations() entries
+   * Convert the Drizzle schema to an intermediate schema representation
    *
-   * Uses official Drizzle v1 types (TableRelationalConfig, Relation, One).
-   * Processes One relations to extract foreign key information and generates
-   * DBML Ref lines. Detects one-to-one relationships with bidirectional checks.
+   * Creates a database-agnostic intermediate representation that can be
+   * used to generate various output formats (DBML, Markdown, JSON, etc.)
    *
-   * @param entries - Array of v1 relation entries from defineRelations()
+   * @returns The intermediate schema representation
    */
-  generateRelationalRefsFromV1(e) {
-    const t = /* @__PURE__ */ new Set();
-    for (const n of e) {
-      const s = g(n.table);
-      for (const o of Object.values(n.relations)) {
-        if (!m(o, b) || o.isReversed)
-          continue;
-        const i = o, r = i.sourceColumns.map((u) => u.name), a = i.targetColumns.map((u) => u.name);
-        if (r.length === 0 || a.length === 0)
-          continue;
-        const l = g(i.targetTable), c = `${s}.${r.join(",")}->${l}.${a.join(",")}`, h = `${l}.${a.join(",")}->${s}.${r.join(",")}`;
-        if (t.has(c) || t.has(h))
-          continue;
-        t.add(c);
-        const f = this.hasV1ReverseOneRelation(
-          e,
-          l,
-          s,
-          a,
-          r
-        ), p = {
-          fromTable: s,
-          fromColumns: r,
-          toTable: l,
-          toColumns: a,
-          type: f ? "-" : ">"
-        };
-        this.generatedRefs.push(p);
+  toIntermediateSchema() {
+    const e = this.getTables(), t = this.getDatabaseType(e[0]), n = e.map(
+      (i) => this.tableToDefinition(i)
+    );
+    let o = [];
+    if (this.hasRelationDefinitions())
+      o = this.createRelationAdapter().extract().map((l) => this.unifiedRelationToDefinition(l));
+    else {
+      this.generatedRefs = [];
+      for (const i of e) {
+        const a = m(i), l = this.getTableConfig(i);
+        l && l.foreignKeys.length > 0 && this.collectForeignKeysFromConfig(a, l.foreignKeys);
       }
+      o = this.generatedRefs.map((i) => this.refToRelationDefinition(i));
     }
+    const s = this.collectEnumDefinitions();
+    return {
+      databaseType: t,
+      tables: n,
+      relations: o,
+      enums: s
+    };
   }
   /**
-   * Check if there's a reverse One relation in v1 entries
+   * Determine the database type from a Drizzle table
    *
-   * Detects one-to-one relationships by checking if the target table
-   * has a matching One relation pointing back to the source table.
-   *
-   * @param entries - All v1 relation entries
-   * @param fromTableName - The table to search for reverse relation
-   * @param toTableName - The expected target table of the reverse relation
-   * @param fromColumns - The expected source columns of the reverse relation
-   * @param toColumns - The expected target columns of the reverse relation
-   * @returns True if a matching reverse One relation exists
+   * @param table - The table to check (can be undefined for empty schemas)
+   * @returns The database type
    */
-  hasV1ReverseOneRelation(e, t, n, s, o) {
-    const i = e.find((r) => g(r.table) === t);
-    if (!i)
-      return !1;
-    for (const r of Object.values(i.relations)) {
-      if (!m(r, b))
-        continue;
-      const a = r;
-      if (g(a.targetTable) !== n)
-        continue;
-      const c = a.sourceColumns.map((f) => f.name), h = a.targetColumns.map((f) => f.name);
-      if (c.length === s.length && h.length === o.length && c.every((f, p) => f === s[p]) && h.every((f, p) => f === o[p]))
-        return !0;
-    }
-    return !1;
+  getDatabaseType(e) {
+    return !e || r(e, c) ? "postgresql" : r(e, f) ? "mysql" : r(e, u) ? "sqlite" : "postgresql";
   }
   /**
-   * Get unique key for a relation to avoid duplicates
-   *
-   * Creates a consistent key by sorting table names alphabetically.
+   * Convert a Drizzle table to a TableDefinition
    *
-   * @param tableName - The source table name
-   * @param relation - The relation object
-   * @returns A unique key string for the relation
+   * @param table - The Drizzle table to convert
+   * @returns The table definition
    */
-  getRelationKey(e, t) {
-    const n = t, s = n.referencedTable ? g(n.referencedTable) : "unknown", o = [e, s].sort();
-    return `${o[0]}-${o[1]}`;
+  tableToDefinition(e) {
+    const t = m(e), n = y(e), o = this.getTableConfig(e), s = Object.values(n).map(
+      (g) => this.columnToDefinition(g, t)
+    ), i = this.extractIndexDefinitions(o), a = this.extractConstraintDefinitions(o), l = this.comments?.tables[t]?.comment;
+    return {
+      name: t,
+      comment: l,
+      columns: s,
+      indexes: i,
+      constraints: a
+    };
   }
   /**
-   * Parse a relation into a GeneratedRef
+   * Convert a Drizzle column to a ColumnDefinition
    *
-   * Extracts relation information from a legacy relation object and converts
-   * it to a GeneratedRef for DBML output.
-   *
-   * @param tableName - The source table name
-   * @param relation - The relation object to parse
-   * @returns GeneratedRef object or undefined if parsing fails
+   * @param column - The Drizzle column to convert
+   * @param tableName - The name of the table containing the column
+   * @returns The column definition
    */
-  parseRelation(e, t) {
-    try {
-      const n = t;
-      if (!n.referencedTable)
-        return;
-      const s = g(n.referencedTable), o = n.sourceColumns || [], i = n.referencedColumns || [];
-      if (o.length === 0 || i.length === 0)
-        return;
-      const r = o.map((c) => c.name), a = i.map((c) => c.name);
-      let l = ">";
-      return n.relationType === "one" && (l = "-"), {
-        fromTable: e,
-        fromColumns: r,
-        toTable: s,
-        toColumns: a,
-        type: l
-      };
-    } catch {
-      return;
-    }
+  columnToDefinition(e, t) {
+    const n = this.comments?.tables[t]?.columns[e.name]?.comment, o = this.getDefaultValue(e);
+    return {
+      name: e.name,
+      type: e.getSQLType(),
+      nullable: !e.notNull,
+      defaultValue: o,
+      primaryKey: e.primary,
+      unique: e.isUnique,
+      autoIncrement: this.dialectConfig.isIncrement(e) || void 0,
+      comment: n
+    };
   }
   /**
-   * Generate a reference line in DBML format
+   * Extract index definitions from table config
    *
-   * Creates a Ref line showing the relationship between tables with optional
-   * onDelete and onUpdate actions.
-   *
-   * @param dbml - The DBML builder to add the reference to
-   * @param ref - The reference definition to generate
-   */
-  generateRef(e, t) {
-    const n = `${this.dialectConfig.escapeName(t.fromTable)}.${t.fromColumns.map((r) => this.dialectConfig.escapeName(r)).join(", ")}`, s = `${this.dialectConfig.escapeName(t.toTable)}.${t.toColumns.map((r) => this.dialectConfig.escapeName(r)).join(", ")}`;
-    let o = `Ref: ${n} ${t.type} ${s}`;
-    const i = [];
-    t.onDelete && t.onDelete !== "no action" && i.push(`delete: ${t.onDelete}`), t.onUpdate && t.onUpdate !== "no action" && i.push(`update: ${t.onUpdate}`), i.length > 0 && (o += ` [${i.join(", ")}]`), e.line(o);
-  }
-  // Helper methods for extracting column information from constraints
-  /**
-   * Get column names from an index definition
-   *
-   * @param idx - The index definition to extract columns from
-   * @returns Array of column names in the index
+   * @param tableConfig - The table configuration
+   * @returns Array of index definitions
    */
-  getIndexColumns(e) {
-    try {
-      return e.config.columns.map((n) => typeof n == "object" && n !== null && "name" in n ? n.name : "").filter(Boolean);
-    } catch {
+  extractIndexDefinitions(e) {
+    if (!e)
       return [];
+    const t = [];
+    for (const n of e.indexes) {
+      const o = n.config.columns.map((s) => s.name);
+      o.length > 0 && t.push({
+        name: n.config.name || `idx_${o.join("_")}`,
+        columns: o,
+        unique: n.config.unique,
+        type: n.config.using
+      });
     }
+    return t;
   }
   /**
-   * Check if an index is unique
+   * Extract constraint definitions from table config
    *
-   * @param idx - The index definition to check
-   * @returns True if the index has the unique flag
+   * @param tableConfig - The table configuration
+   * @returns Array of constraint definitions
    */
-  isUniqueIndex(e) {
-    try {
-      return e.config.unique === !0;
-    } catch {
-      return !1;
+  extractConstraintDefinitions(e) {
+    if (!e)
+      return [];
+    const t = [];
+    for (const n of e.primaryKeys) {
+      const o = n.columns.map((s) => s.name);
+      o.length > 0 && t.push({
+        name: n.name || `pk_${o.join("_")}`,
+        type: "primary_key",
+        columns: o
+      });
+    }
+    for (const n of e.uniqueConstraints) {
+      const o = n.columns.map((s) => s.name);
+      o.length > 0 && t.push({
+        name: n.name || `uq_${o.join("_")}`,
+        type: "unique",
+        columns: o
+      });
     }
+    for (const n of e.foreignKeys) {
+      const o = this.parseForeignKeyForConstraint(n);
+      o && t.push(o);
+    }
+    return t;
   }
   /**
-   * Get column names from a primary key constraint
-   *
-   * @param pk - The primary key definition to extract columns from
-   * @returns Array of column names in the primary key
-   */
-  getPrimaryKeyColumns(e) {
-    try {
-      return e.columns.map((n) => n.name);
-    } catch {
-      return [];
+   * Parse a foreign key into a ConstraintDefinition
+   *
+   * @param fk - The foreign key definition
+   * @returns ConstraintDefinition
+   */
+  parseForeignKeyForConstraint(e) {
+    const t = e.reference(), n = t.columns.map((i) => i.name), o = t.foreignColumns.map((i) => i.name), s = m(t.foreignTable);
+    return {
+      name: e.name || `fk_${n.join("_")}_${s}`,
+      type: "foreign_key",
+      columns: n,
+      referencedTable: s,
+      referencedColumns: o
+    };
+  }
+  /**
+   * Convert a GeneratedRef to a RelationDefinition
+   *
+   * @param ref - The generated reference
+   * @returns The relation definition
+   */
+  refToRelationDefinition(e) {
+    let t;
+    switch (e.type) {
+      case "-":
+        t = "one-to-one";
+        break;
+      case ">":
+        t = "many-to-one";
+        break;
+      case "<":
+        t = "one-to-many";
+        break;
+      default:
+        t = "many-to-one";
     }
+    return {
+      fromTable: e.fromTable,
+      fromColumns: e.fromColumns,
+      toTable: e.toTable,
+      toColumns: e.toColumns,
+      type: t,
+      onDelete: e.onDelete,
+      onUpdate: e.onUpdate
+    };
   }
   /**
-   * Get column names from a unique constraint
+   * Collect enum definitions from the schema
+   *
+   * Override in subclasses for dialect-specific enum handling (e.g., PostgreSQL)
    *
-   * @param uc - The unique constraint definition to extract columns from
-   * @returns Array of column names in the unique constraint
+   * @returns Array of enum definitions (empty by default)
    */
-  getUniqueConstraintColumns(e) {
-    try {
-      return e.columns.map((n) => n.name);
-    } catch {
-      return [];
-    }
+  collectEnumDefinitions() {
+    return [];
   }
 }
-function P(y, e) {
-  const t = O(y), n = x(t);
-  q(n, { recursive: !0 }), V(t, e, "utf-8");
-}
-function $(y) {
-  return y.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
+function P(p, e) {
+  const t = R(p), n = q(t);
+  C(n, { recursive: !0 }), D(t, e, "utf-8");
 }
 export {
-  B as BaseGenerator,
-  D as DbmlBuilder,
+  N as BaseGenerator,
   P as writeDbmlFile
 };
 //# sourceMappingURL=common.js.map