drizzle-docs-generator 0.1.0

package/dist/generator/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sources":["../../src/generator/common.ts"],"sourcesContent":["import {\n  type AnyColumn,\n  type Table,\n  getTableColumns,\n  getTableName,\n  is,\n  Relation,\n  One,\n} from \"drizzle-orm\";\nimport type { AnyRelation, TableRelationalConfig } from \"drizzle-orm/relations\";\nimport { PgTable, getTableConfig as getPgTableConfig } from \"drizzle-orm/pg-core\";\n\n/**\n * Legacy v0 Relations type (for backward compatibility with relations())\n * This is a simplified type - the actual structure is more complex\n */\ntype LegacyRelations = {\n  table: Table;\n  config: Record<string, unknown>;\n};\nimport { MySqlTable, getTableConfig as getMySqlTableConfig } from \"drizzle-orm/mysql-core\";\nimport { SQLiteTable, getTableConfig as getSqliteTableConfig } from \"drizzle-orm/sqlite-core\";\nimport { writeFileSync, mkdirSync } from \"node:fs\";\nimport { dirname, resolve } from \"node:path\";\nimport type { GeneratedRef, GenerateOptions } from \"../types\";\nimport { extractComments, type SchemaComments } from \"../parser/comments\";\nimport { extractRelations, type SchemaRelations } from \"../parser/relations\";\n\n/**\n * Simple DBML string builder\n */\nexport class DbmlBuilder {\n  private lines: string[] = [];\n  private indentLevel = 0;\n\n  /**\n   * Increase the indentation level by one\n   * @returns This instance for method chaining\n   */\n  indent(): this {\n    this.indentLevel++;\n    return this;\n  }\n\n  /**\n   * Decrease the indentation level by one (minimum 0)\n   * @returns This instance for method chaining\n   */\n  dedent(): this {\n    this.indentLevel = Math.max(0, this.indentLevel - 1);\n    return this;\n  }\n\n  /**\n   * Add a line with the current indentation level\n   * @param content - The content to add (empty string adds a blank line)\n   * @returns This instance for method chaining\n   */\n  line(content: string = \"\"): this {\n    const indent = \"  \".repeat(this.indentLevel);\n    this.lines.push(content ? `${indent}${content}` : \"\");\n    return this;\n  }\n\n  /**\n   * Build the final DBML string from all added lines\n   * @returns The complete DBML content as a string\n   */\n  build(): string {\n    return this.lines.join(\"\\n\");\n  }\n}\n\n/**\n * Configuration for different database dialects\n */\nexport interface DialectConfig {\n  escapeName: (name: string) => string;\n  isIncrement: (column: AnyColumn) => boolean;\n}\n\n/**\n * Table configuration extracted from Drizzle tables\n * Using 'any' types for dialect-agnostic handling\n */\nexport interface TableConfig {\n  indexes: unknown[];\n  primaryKeys: unknown[];\n  uniqueConstraints: unknown[];\n  foreignKeys: unknown[];\n}\n\n// Use official v1 types from drizzle-orm/relations:\n// - TableRelationalConfig: { table, name, relations: Record<string, AnyRelation> }\n// - AnyRelation: Relation with sourceColumns, targetColumns, relationType, etc.\n\n/**\n * Base generator class for DBML generation\n */\nexport abstract class BaseGenerator<\n  TSchema extends Record<string, unknown> = Record<string, unknown>,\n> {\n  protected schema: TSchema;\n  protected relational: boolean;\n  protected generatedRefs: GeneratedRef[] = [];\n  protected comments: SchemaComments | undefined;\n  protected parsedRelations: SchemaRelations | undefined;\n  protected source: string | undefined;\n  protected abstract dialectConfig: DialectConfig;\n\n  /**\n   * Create a new generator instance\n   * @param options - Configuration options including schema, relational mode, source code, and comments\n   */\n  constructor(options: GenerateOptions<TSchema>) {\n    this.schema = options.schema;\n    this.relational = options.relational ?? false;\n    this.source = options.source;\n\n    // Initialize comments from options\n    if (options.comments) {\n      this.comments = options.comments;\n    } else if (this.source) {\n      this.comments = extractComments(this.source);\n    }\n\n    // Extract relations from source if relational mode is enabled\n    if (this.relational && this.source) {\n      this.parsedRelations = extractRelations(this.source);\n    }\n  }\n\n  /**\n   * Generate complete DBML output from the schema\n   *\n   * Creates DBML representation including:\n   * - Table definitions with columns, indexes, and constraints\n   * - Foreign key references (from table config or relations)\n   * - Comments for tables and columns\n   *\n   * @returns The complete DBML string\n   */\n  generate(): string {\n    const dbml = new DbmlBuilder();\n    const tables = this.getTables();\n    const v0Relations = this.getV0Relations();\n    const v1Entries = this.getV1RelationEntries();\n\n    // Generate tables\n    for (const table of tables) {\n      this.generateTable(dbml, table);\n      dbml.line();\n    }\n\n    // Generate references from relations\n    if (this.relational) {\n      // Try v1 defineRelations() first - runtime object parsing with official types\n      if (v1Entries.length > 0) {\n        this.generateRelationalRefsFromV1(v1Entries);\n      }\n      // Fall back to v0 relations() with AST parsing\n      else if (v0Relations.length > 0 || this.parsedRelations) {\n        this.generateRelationalRefsFromV0();\n      }\n    }\n\n    // Add collected refs\n    for (const ref of this.generatedRefs) {\n      this.generateRef(dbml, ref);\n    }\n\n    return dbml.build().trim();\n  }\n\n  /**\n   * Get all tables from schema\n   *\n   * Extracts all Drizzle table objects from the schema by checking each value\n   * with isTable() method.\n   *\n   * @returns Array of table objects\n   */\n  protected getTables(): Table[] {\n    const tables: Table[] = [];\n    for (const value of Object.values(this.schema)) {\n      if (this.isTable(value)) {\n        tables.push(value as Table);\n      }\n    }\n    return tables;\n  }\n\n  /**\n   * Check if a value is a Drizzle table\n   *\n   * Validates whether a value is a table instance from any supported dialect\n   * (PostgreSQL, MySQL, or SQLite).\n   *\n   * @param value - The value to check\n   * @returns True if value is a Drizzle table\n   */\n  protected isTable(value: unknown): boolean {\n    return is(value, PgTable) || is(value, MySqlTable) || is(value, SQLiteTable);\n  }\n\n  /**\n   * Get all v0 relations from schema (legacy relations() API)\n   *\n   * Extracts legacy relations defined using the old relations() API.\n   * These are identified by having 'table' and 'config' properties.\n   *\n   * @returns Array of legacy relation objects\n   */\n  protected getV0Relations(): LegacyRelations[] {\n    const relations: LegacyRelations[] = [];\n    for (const value of Object.values(this.schema)) {\n      if (this.isV0Relations(value)) {\n        relations.push(value as LegacyRelations);\n      }\n    }\n    return relations;\n  }\n\n  /**\n   * Check if a value is a Drizzle v0 relations object (from relations())\n   *\n   * Validates the legacy relations() format by checking for 'table' and 'config' properties.\n   *\n   * @param value - The value to check\n   * @returns True if value is a legacy relations object\n   */\n  protected isV0Relations(value: unknown): boolean {\n    if (typeof value !== \"object\" || value === null) {\n      return false;\n    }\n    // v0 Relations objects have 'table' and 'config' properties\n    return (\n      \"table\" in value &&\n      \"config\" in value &&\n      typeof (value as Record<string, unknown>).config === \"object\"\n    );\n  }\n\n  /**\n   * Check if a value is a v1 relation entry (from defineRelations())\n   *\n   * Uses official Drizzle v1 types: TableRelationalConfig with Relation instances.\n   * Validates the structure has 'table', 'name', and 'relations' properties with valid types.\n   *\n   * @param value - The value to check\n   * @returns True if value is a v1 relation entry\n   */\n  protected isV1RelationEntry(value: unknown): value is TableRelationalConfig {\n    if (typeof value !== \"object\" || value === null) {\n      return false;\n    }\n    const obj = value as Record<string, unknown>;\n    if (\n      !(\"table\" in obj) ||\n      !(\"name\" in obj) ||\n      typeof obj.name !== \"string\" ||\n      !(\"relations\" in obj) ||\n      typeof obj.relations !== \"object\" ||\n      obj.relations === null\n    ) {\n      return false;\n    }\n    // Check that 'relations' contains Relation instances (using drizzle-orm is())\n    const relations = obj.relations as Record<string, unknown>;\n    const relationValues = Object.values(relations);\n    // Empty relations object is valid, but if there are entries, they must be Relations\n    if (relationValues.length > 0) {\n      return relationValues.some((rel) => is(rel, Relation));\n    }\n    // If no relations defined, also check table is valid\n    return this.isTable(obj.table);\n  }\n\n  /**\n   * Get all v1 relation entries from schema (defineRelations() API)\n   *\n   * Handles both individual entries and the full defineRelations() result object.\n   * Extracts relation configurations that use the modern v1 API with official types.\n   *\n   * @returns Array of v1 relation entries\n   */\n  protected getV1RelationEntries(): TableRelationalConfig[] {\n    const entries: TableRelationalConfig[] = [];\n    for (const value of Object.values(this.schema)) {\n      // Check if it's an individual relation entry\n      if (this.isV1RelationEntry(value)) {\n        entries.push(value);\n      }\n      // Check if it's the full defineRelations() result object\n      // (an object where each value is a relation entry)\n      else if (this.isV1DefineRelationsResult(value)) {\n        for (const entry of Object.values(value as Record<string, unknown>)) {\n          if (this.isV1RelationEntry(entry)) {\n            entries.push(entry);\n          }\n        }\n      }\n    }\n    return entries;\n  }\n\n  /**\n   * Check if a value is a full v1 defineRelations() result object\n   *\n   * This is an object where all values are TableRelationalConfig objects.\n   * Used to detect the full result of calling defineRelations() in v1.\n   *\n   * @param value - The value to check\n   * @returns True if value is a full defineRelations() result\n   */\n  protected isV1DefineRelationsResult(value: unknown): boolean {\n    if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n      return false;\n    }\n    const obj = value as Record<string, unknown>;\n    const values = Object.values(obj);\n    // Must have at least one entry and all must be relation entries\n    return values.length > 0 && values.every((v) => this.isV1RelationEntry(v));\n  }\n\n  /**\n   * Generate a table definition in DBML format\n   *\n   * Creates the complete table definition including columns, indexes, constraints,\n   * and table-level comments. Also collects foreign keys if not in relational mode.\n   *\n   * @param dbml - The DBML builder to add the table to\n   * @param table - The Drizzle table to generate\n   */\n  protected generateTable(dbml: DbmlBuilder, table: Table): void {\n    const tableName = getTableName(table);\n    const columns = getTableColumns(table);\n    const escapedName = this.dialectConfig.escapeName(tableName);\n\n    dbml.line(`Table ${escapedName} {`);\n    dbml.indent();\n\n    // Generate columns\n    for (const column of Object.values(columns)) {\n      this.generateColumn(dbml, column, tableName);\n    }\n\n    // Get table configuration (indexes, constraints, etc.)\n    const tableConfig = this.getTableConfig(table);\n\n    // Generate indexes block if any\n    if (tableConfig) {\n      this.generateIndexesBlock(dbml, tableConfig);\n    }\n\n    // Add table-level Note if comment exists\n    const tableComment = this.comments?.tables[tableName]?.comment;\n    if (tableComment) {\n      dbml.line();\n      dbml.line(`Note: '${escapeDbmlString(tableComment)}'`);\n    }\n\n    dbml.dedent();\n    dbml.line(\"}\");\n\n    // Collect foreign keys if not using relational mode\n    if (!this.relational && tableConfig && tableConfig.foreignKeys.length > 0) {\n      this.collectForeignKeysFromConfig(tableName, tableConfig.foreignKeys);\n    }\n  }\n\n  /**\n   * Get table configuration from a Drizzle table\n   *\n   * Extracts indexes, primary keys, unique constraints, and foreign keys\n   * from the table using the appropriate dialect-specific config getter.\n   *\n   * @param table - The Drizzle table to get configuration from\n   * @returns Table configuration or undefined if dialect is not supported\n   */\n  protected getTableConfig(table: Table): TableConfig | undefined {\n    // Detect dialect and use appropriate config getter\n    if (is(table, PgTable)) {\n      const config = getPgTableConfig(table);\n      return {\n        indexes: config.indexes || [],\n        primaryKeys: config.primaryKeys || [],\n        uniqueConstraints: config.uniqueConstraints || [],\n        foreignKeys: config.foreignKeys || [],\n      };\n    }\n    if (is(table, MySqlTable)) {\n      const config = getMySqlTableConfig(table);\n      return {\n        indexes: config.indexes || [],\n        primaryKeys: config.primaryKeys || [],\n        uniqueConstraints: config.uniqueConstraints || [],\n        foreignKeys: config.foreignKeys || [],\n      };\n    }\n    if (is(table, SQLiteTable)) {\n      const config = getSqliteTableConfig(table);\n      return {\n        indexes: config.indexes || [],\n        primaryKeys: config.primaryKeys || [],\n        uniqueConstraints: config.uniqueConstraints || [],\n        foreignKeys: config.foreignKeys || [],\n      };\n    }\n    return undefined;\n  }\n\n  /**\n   * Generate a column definition in DBML format\n   *\n   * Creates a column line with type and attributes (primary key, not null, unique, etc.)\n   * and includes column-level comments if available.\n   *\n   * @param dbml - The DBML builder to add the column to\n   * @param column - The Drizzle column to generate\n   * @param tableName - Optional table name for looking up comments\n   */\n  protected generateColumn(dbml: DbmlBuilder, column: AnyColumn, tableName?: string): void {\n    const name = this.dialectConfig.escapeName(column.name);\n    const type = this.getColumnType(column);\n    const attrs = this.getColumnAttributes(column, tableName);\n    const attrStr = this.formatAttributes(attrs);\n\n    if (attrStr) {\n      dbml.line(`${name} ${type} [${attrStr}]`);\n    } else {\n      dbml.line(`${name} ${type}`);\n    }\n  }\n\n  /**\n   * Get the SQL type for a column\n   *\n   * @param column - The column to get the SQL type from\n   * @returns The SQL type string (e.g., \"varchar\", \"integer\")\n   */\n  protected getColumnType(column: AnyColumn): string {\n    return column.getSQLType();\n  }\n\n  /**\n   * Get column attributes for DBML\n   *\n   * Extracts attributes like primary key, not null, unique, increment, default value,\n   * and note from the column. Uses column metadata and comments if available.\n   *\n   * @param column - The column to get attributes from\n   * @param tableName - Optional table name for looking up comments\n   * @returns Array of attribute strings for DBML format\n   */\n  protected getColumnAttributes(column: AnyColumn, tableName?: string): string[] {\n    const attrs: string[] = [];\n\n    if (column.primary) {\n      attrs.push(\"primary key\");\n    }\n    if (column.notNull) {\n      attrs.push(\"not null\");\n    }\n    if (column.isUnique) {\n      attrs.push(\"unique\");\n    }\n    if (this.dialectConfig.isIncrement(column)) {\n      attrs.push(\"increment\");\n    }\n\n    const defaultValue = this.getDefaultValue(column);\n    if (defaultValue !== undefined) {\n      attrs.push(`default: ${defaultValue}`);\n    }\n\n    // Add note attribute if column comment exists\n    if (tableName) {\n      const columnComment = this.comments?.tables[tableName]?.columns[column.name]?.comment;\n      if (columnComment) {\n        attrs.push(`note: '${escapeDbmlString(columnComment)}'`);\n      }\n    }\n\n    return attrs;\n  }\n\n  /**\n   * Format attributes into a string\n   *\n   * @param attrs - Array of attribute strings\n   * @returns Comma-separated attribute string\n   */\n  protected formatAttributes(attrs: string[]): string {\n    return attrs.join(\", \");\n  }\n\n  /**\n   * Get the default value for a column\n   *\n   * Extracts and formats the default value from a column, handling SQL expressions,\n   * objects, and primitive values. Returns undefined if no default value exists.\n   *\n   * @param column - The column to get the default value from\n   * @returns Formatted default value string or undefined\n   */\n  protected getDefaultValue(column: AnyColumn): string | undefined {\n    if (!column.hasDefault) {\n      return undefined;\n    }\n\n    const defaultValue = column.default;\n\n    if (defaultValue === null) {\n      return \"null\";\n    }\n\n    if (defaultValue === undefined) {\n      return undefined;\n    }\n\n    // Handle SQL expressions\n    if (typeof defaultValue === \"object\" && defaultValue !== null) {\n      if (\"queryChunks\" in defaultValue) {\n        // It's a SQL template\n        const chunks = (defaultValue as { queryChunks: unknown[] }).queryChunks;\n        const sqlParts: string[] = [];\n        for (const chunk of chunks) {\n          if (typeof chunk === \"string\") {\n            sqlParts.push(chunk);\n          } else if (typeof chunk === \"object\" && chunk !== null && \"value\" in chunk) {\n            sqlParts.push(String((chunk as { value: unknown }).value));\n          }\n        }\n        return `\\`${sqlParts.join(\"\")}\\``;\n      }\n      if (\"sql\" in defaultValue) {\n        return `\\`${(defaultValue as { sql: string }).sql}\\``;\n      }\n      // JSON object\n      return `'${JSON.stringify(defaultValue)}'`;\n    }\n\n    // Handle primitives\n    if (typeof defaultValue === \"string\") {\n      return `'${defaultValue.replace(/'/g, \"\\\\'\")}'`;\n    }\n    if (typeof defaultValue === \"number\" || typeof defaultValue === \"boolean\") {\n      return String(defaultValue);\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Generate indexes block from table configuration\n   *\n   * Creates the indexes block containing primary keys, unique constraints,\n   * and regular indexes with their respective attributes.\n   *\n   * @param dbml - The DBML builder to add the indexes block to\n   * @param tableConfig - The table configuration containing index information\n   */\n  protected generateIndexesBlock(dbml: DbmlBuilder, tableConfig: TableConfig): void {\n    const { indexes, primaryKeys, uniqueConstraints } = tableConfig;\n\n    if (indexes.length === 0 && primaryKeys.length === 0 && uniqueConstraints.length === 0) {\n      return;\n    }\n\n    dbml.line();\n    dbml.line(\"indexes {\");\n    dbml.indent();\n\n    // Primary keys\n    for (const pk of primaryKeys) {\n      const columns = this.getPrimaryKeyColumns(pk);\n      if (columns.length > 0) {\n        const colStr = columns.map((c) => this.dialectConfig.escapeName(c)).join(\", \");\n        dbml.line(`(${colStr}) [pk]`);\n      }\n    }\n\n    // Unique constraints\n    for (const uc of uniqueConstraints) {\n      const columns = this.getUniqueConstraintColumns(uc);\n      if (columns.length > 0) {\n        const colStr = columns.map((c) => this.dialectConfig.escapeName(c)).join(\", \");\n        dbml.line(`(${colStr}) [unique]`);\n      }\n    }\n\n    // Regular indexes\n    for (const idx of indexes) {\n      const columns = this.getIndexColumns(idx);\n      if (columns.length > 0) {\n        const colStr = columns.map((c) => this.dialectConfig.escapeName(c)).join(\", \");\n        const attrs: string[] = [];\n        if (this.isUniqueIndex(idx)) {\n          attrs.push(\"unique\");\n        }\n        const attrStr = attrs.length > 0 ? ` [${attrs.join(\", \")}]` : \"\";\n        dbml.line(`(${colStr})${attrStr}`);\n      }\n    }\n\n    dbml.dedent();\n    dbml.line(\"}\");\n  }\n\n  /**\n   * Collect foreign keys from table configuration\n   *\n   * Parses all foreign key definitions from the table config and adds them\n   * to the generatedRefs collection for later output.\n   *\n   * @param tableName - The name of the source table\n   * @param foreignKeys - Array of foreign key definitions from table config\n   */\n  protected collectForeignKeysFromConfig(tableName: string, foreignKeys: unknown[]): void {\n    for (const fk of foreignKeys) {\n      const ref = this.parseForeignKey(tableName, fk);\n      if (ref) {\n        this.generatedRefs.push(ref);\n      }\n    }\n  }\n\n  /**\n   * Parse a foreign key into a GeneratedRef\n   *\n   * Extracts foreign key information (source/target tables and columns, actions)\n   * and converts it to a GeneratedRef object for DBML output.\n   *\n   * @param tableName - The name of the source table\n   * @param fk - The foreign key definition to parse\n   * @returns GeneratedRef object or undefined if parsing fails\n   */\n  protected parseForeignKey(tableName: string, fk: unknown): GeneratedRef | undefined {\n    try {\n      const fkObj = fk as {\n        reference: () => {\n          columns: Array<{ name: string }>;\n          foreignColumns: Array<{ name: string }>;\n          foreignTable: Table;\n        };\n        onDelete?: string;\n        onUpdate?: string;\n      };\n      const reference = fkObj.reference();\n      const fromColumns = reference.columns.map((c) => c.name);\n      const toColumns = reference.foreignColumns.map((c) => c.name);\n      const toTable = getTableName(reference.foreignTable);\n\n      return {\n        fromTable: tableName,\n        fromColumns,\n        toTable,\n        toColumns,\n        type: \">\",\n        onDelete: fkObj.onDelete,\n        onUpdate: fkObj.onUpdate,\n      };\n    } catch {\n      return undefined;\n    }\n  }\n\n  /**\n   * Get a mapping from variable names to table names in the schema\n   *\n   * Creates a map from TypeScript variable names (e.g., \"usersTable\") to\n   * actual database table names (e.g., \"users\").\n   *\n   * @returns Map of variable names to table names\n   */\n  protected getTableNameMapping(): Map<string, string> {\n    const mapping = new Map<string, string>();\n    for (const [varName, value] of Object.entries(this.schema)) {\n      if (this.isTable(value)) {\n        const tableName = getTableName(value as Table);\n        mapping.set(varName, tableName);\n      }\n    }\n    return mapping;\n  }\n\n  /**\n   * Get a mapping from TypeScript property names to database column names for a table\n   *\n   * Creates a map from TypeScript property names (e.g., \"authorId\") to\n   * actual database column names (e.g., \"author_id\").\n   *\n   * @param tableVarName - The variable name of the table in the schema\n   * @returns Map of property names to column names\n   */\n  protected getColumnNameMapping(tableVarName: string): Map<string, string> {\n    const mapping = new Map<string, string>();\n    const table = this.schema[tableVarName];\n    if (table && this.isTable(table)) {\n      const columns = getTableColumns(table as Table);\n      for (const [propName, column] of Object.entries(columns)) {\n        mapping.set(propName, column.name);\n      }\n    }\n    return mapping;\n  }\n\n  /**\n   * Check if there's a reverse one() relation (B->A when we have A->B)\n   *\n   * Used to detect one-to-one relationships by checking if both tables\n   * have one() relations pointing to each other.\n   *\n   * @param sourceTable - The source table variable name\n   * @param targetTable - The target table variable name\n   * @param sourceFields - The source table's field names\n   * @param targetReferences - The target table's reference column names\n   * @returns True if a reverse one() relation exists\n   */\n  protected hasReverseOneRelation(\n    sourceTable: string,\n    targetTable: string,\n    sourceFields: string[],\n    targetReferences: string[],\n  ): boolean {\n    if (!this.parsedRelations) return false;\n\n    // Look for a one() relation from targetTable to sourceTable\n    for (const relation of this.parsedRelations.relations) {\n      if (\n        relation.type === \"one\" &&\n        relation.sourceTable === targetTable &&\n        relation.targetTable === sourceTable &&\n        relation.fields.length > 0 &&\n        relation.references.length > 0\n      ) {\n        // Check if the fields/references are the reverse of each other\n        // A->B: fields=[A.col], references=[B.col]\n        // B->A: fields=[B.col], references=[A.col]\n        const reverseFields = relation.fields;\n        const reverseReferences = relation.references;\n\n        // The reverse relation's fields should match our references\n        // and the reverse relation's references should match our fields\n        if (\n          this.arraysEqual(reverseFields, targetReferences) &&\n          this.arraysEqual(reverseReferences, sourceFields)\n        ) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Helper to check if two arrays are equal\n   *\n   * @param a - First array\n   * @param b - Second array\n   * @returns True if arrays have same length and same elements in order\n   */\n  private arraysEqual(a: string[], b: string[]): boolean {\n    if (a.length !== b.length) return false;\n    return a.every((val, i) => val === b[i]);\n  }\n\n  /**\n   * Generate references from v0 relations() API\n   *\n   * Uses TypeScript Compiler API to parse relations() definitions from source file\n   * and extract fields/references to generate DBML Ref lines.\n   *\n   * Detects one-to-one relationships when bidirectional one() relations exist.\n   */\n  protected generateRelationalRefsFromV0(): void {\n    if (!this.parsedRelations || this.parsedRelations.relations.length === 0) {\n      return;\n    }\n\n    const tableNameMapping = this.getTableNameMapping();\n    const processedRefs = new Set<string>();\n\n    for (const parsedRelation of this.parsedRelations.relations) {\n      // Only process one() relations with fields and references\n      // many() relations are typically the inverse and don't have field info\n      if (parsedRelation.type !== \"one\") {\n        continue;\n      }\n\n      if (parsedRelation.fields.length === 0 || parsedRelation.references.length === 0) {\n        continue;\n      }\n\n      // Map variable names to actual table names\n      const fromTableName = tableNameMapping.get(parsedRelation.sourceTable);\n      const toTableName = tableNameMapping.get(parsedRelation.targetTable);\n\n      if (!fromTableName || !toTableName) {\n        continue;\n      }\n\n      // Get column name mappings (TypeScript property names -> database column names)\n      const fromColumnMapping = this.getColumnNameMapping(parsedRelation.sourceTable);\n      const toColumnMapping = this.getColumnNameMapping(parsedRelation.targetTable);\n\n      // Map TypeScript field names to database column names\n      const fromColumns = parsedRelation.fields.map(\n        (field) => fromColumnMapping.get(field) || field,\n      );\n      const toColumns = parsedRelation.references.map((ref) => toColumnMapping.get(ref) || ref);\n\n      // Create a unique key to avoid duplicate refs (bidirectional)\n      const refKey = `${fromTableName}.${fromColumns.join(\",\")}-${toTableName}.${toColumns.join(\",\")}`;\n      const reverseRefKey = `${toTableName}.${toColumns.join(\",\")}-${fromTableName}.${fromColumns.join(\",\")}`;\n\n      if (processedRefs.has(refKey) || processedRefs.has(reverseRefKey)) {\n        continue;\n      }\n      processedRefs.add(refKey);\n\n      // Check if this is a one-to-one relationship (bidirectional one())\n      const isOneToOne = this.hasReverseOneRelation(\n        parsedRelation.sourceTable,\n        parsedRelation.targetTable,\n        parsedRelation.fields,\n        parsedRelation.references,\n      );\n\n      // Create GeneratedRef\n      // one-to-one: \"-\", many-to-one: \">\"\n      const ref: GeneratedRef = {\n        fromTable: fromTableName,\n        fromColumns,\n        toTable: toTableName,\n        toColumns,\n        type: isOneToOne ? \"-\" : \">\",\n      };\n\n      this.generatedRefs.push(ref);\n    }\n  }\n\n  /**\n   * Generate references from v1 defineRelations() entries\n   *\n   * Uses official Drizzle v1 types (TableRelationalConfig, Relation, One).\n   * Processes One relations to extract foreign key information and generates\n   * DBML Ref lines. Detects one-to-one relationships with bidirectional checks.\n   *\n   * @param entries - Array of v1 relation entries from defineRelations()\n   */\n  protected generateRelationalRefsFromV1(entries: TableRelationalConfig[]): void {\n    const processedRefs = new Set<string>();\n\n    for (const entry of entries) {\n      const sourceTableName = getTableName(entry.table as Table);\n\n      for (const relation of Object.values(entry.relations)) {\n        // Only process One relations as they define the FK direction\n        // Many relations are the inverse and don't add new information\n        if (!is(relation, One)) {\n          continue;\n        }\n\n        // Skip reversed relations (they are auto-generated inverse relations)\n        if ((relation as AnyRelation).isReversed) {\n          continue;\n        }\n\n        // Get source and target column names (using official Relation properties)\n        const rel = relation as AnyRelation;\n        const sourceColumns = rel.sourceColumns.map((col) => col.name);\n        const targetColumns = rel.targetColumns.map((col) => col.name);\n\n        if (sourceColumns.length === 0 || targetColumns.length === 0) {\n          continue;\n        }\n\n        const targetTableName = getTableName(rel.targetTable as Table);\n\n        // Create a unique key to avoid duplicate refs\n        const refKey = `${sourceTableName}.${sourceColumns.join(\",\")}->${targetTableName}.${targetColumns.join(\",\")}`;\n        const reverseRefKey = `${targetTableName}.${targetColumns.join(\",\")}->${sourceTableName}.${sourceColumns.join(\",\")}`;\n\n        if (processedRefs.has(refKey) || processedRefs.has(reverseRefKey)) {\n          continue;\n        }\n        processedRefs.add(refKey);\n\n        // Check if there's a reverse one() relation (indicating one-to-one)\n        const isOneToOne = this.hasV1ReverseOneRelation(\n          entries,\n          targetTableName,\n          sourceTableName,\n          targetColumns,\n          sourceColumns,\n        );\n\n        const ref: GeneratedRef = {\n          fromTable: sourceTableName,\n          fromColumns: sourceColumns,\n          toTable: targetTableName,\n          toColumns: targetColumns,\n          type: isOneToOne ? \"-\" : \">\",\n        };\n\n        this.generatedRefs.push(ref);\n      }\n    }\n  }\n\n  /**\n   * Check if there's a reverse One relation in v1 entries\n   *\n   * Detects one-to-one relationships by checking if the target table\n   * has a matching One relation pointing back to the source table.\n   *\n   * @param entries - All v1 relation entries\n   * @param fromTableName - The table to search for reverse relation\n   * @param toTableName - The expected target table of the reverse relation\n   * @param fromColumns - The expected source columns of the reverse relation\n   * @param toColumns - The expected target columns of the reverse relation\n   * @returns True if a matching reverse One relation exists\n   */\n  protected hasV1ReverseOneRelation(\n    entries: TableRelationalConfig[],\n    fromTableName: string,\n    toTableName: string,\n    fromColumns: string[],\n    toColumns: string[],\n  ): boolean {\n    const fromEntry = entries.find((e) => getTableName(e.table as Table) === fromTableName);\n    if (!fromEntry) {\n      return false;\n    }\n\n    for (const relation of Object.values(fromEntry.relations)) {\n      if (!is(relation, One)) {\n        continue;\n      }\n\n      const rel = relation as AnyRelation;\n      const relTargetName = getTableName(rel.targetTable as Table);\n      if (relTargetName !== toTableName) {\n        continue;\n      }\n\n      const relSourceCols = rel.sourceColumns.map((col) => col.name);\n      const relTargetCols = rel.targetColumns.map((col) => col.name);\n\n      // Check if columns match in reverse\n      if (\n        relSourceCols.length === fromColumns.length &&\n        relTargetCols.length === toColumns.length &&\n        relSourceCols.every((col, i) => col === fromColumns[i]) &&\n        relTargetCols.every((col, i) => col === toColumns[i])\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Get unique key for a relation to avoid duplicates\n   *\n   * Creates a consistent key by sorting table names alphabetically.\n   *\n   * @param tableName - The source table name\n   * @param relation - The relation object\n   * @returns A unique key string for the relation\n   */\n  protected getRelationKey(tableName: string, relation: unknown): string {\n    const rel = relation as { referencedTable?: Table };\n    const referencedTable = rel.referencedTable ? getTableName(rel.referencedTable) : \"unknown\";\n    const tables = [tableName, referencedTable].sort();\n    return `${tables[0]}-${tables[1]}`;\n  }\n\n  /**\n   * Parse a relation into a GeneratedRef\n   *\n   * Extracts relation information from a legacy relation object and converts\n   * it to a GeneratedRef for DBML output.\n   *\n   * @param tableName - The source table name\n   * @param relation - The relation object to parse\n   * @returns GeneratedRef object or undefined if parsing fails\n   */\n  protected parseRelation(tableName: string, relation: unknown): GeneratedRef | undefined {\n    try {\n      const rel = relation as {\n        referencedTable?: Table;\n        sourceColumns?: AnyColumn[];\n        referencedColumns?: AnyColumn[];\n        relationType?: string;\n      };\n\n      if (!rel.referencedTable) {\n        return undefined;\n      }\n\n      const referencedTable = getTableName(rel.referencedTable);\n\n      // Try to get field info from the relation\n      const fields = rel.sourceColumns || [];\n      const references = rel.referencedColumns || [];\n\n      if (fields.length === 0 || references.length === 0) {\n        // Cannot generate ref without column info\n        return undefined;\n      }\n\n      const fromColumns = fields.map((c: AnyColumn) => c.name);\n      const toColumns = references.map((c: AnyColumn) => c.name);\n\n      // Determine relation type\n      let type: \"<\" | \">\" | \"-\" = \">\";\n      if (rel.relationType === \"one\") {\n        type = \"-\";\n      }\n\n      return {\n        fromTable: tableName,\n        fromColumns,\n        toTable: referencedTable,\n        toColumns,\n        type,\n      };\n    } catch {\n      return undefined;\n    }\n  }\n\n  /**\n   * Generate a reference line in DBML format\n   *\n   * Creates a Ref line showing the relationship between tables with optional\n   * onDelete and onUpdate actions.\n   *\n   * @param dbml - The DBML builder to add the reference to\n   * @param ref - The reference definition to generate\n   */\n  protected generateRef(dbml: DbmlBuilder, ref: GeneratedRef): void {\n    const from = `${this.dialectConfig.escapeName(ref.fromTable)}.${ref.fromColumns.map((c) => this.dialectConfig.escapeName(c)).join(\", \")}`;\n    const to = `${this.dialectConfig.escapeName(ref.toTable)}.${ref.toColumns.map((c) => this.dialectConfig.escapeName(c)).join(\", \")}`;\n\n    let refLine = `Ref: ${from} ${ref.type} ${to}`;\n\n    const attrs: string[] = [];\n    if (ref.onDelete && ref.onDelete !== \"no action\") {\n      attrs.push(`delete: ${ref.onDelete}`);\n    }\n    if (ref.onUpdate && ref.onUpdate !== \"no action\") {\n      attrs.push(`update: ${ref.onUpdate}`);\n    }\n\n    if (attrs.length > 0) {\n      refLine += ` [${attrs.join(\", \")}]`;\n    }\n\n    dbml.line(refLine);\n  }\n\n  // Helper methods for extracting column information from constraints\n\n  /**\n   * Get column names from an index definition\n   *\n   * @param idx - The index definition to extract columns from\n   * @returns Array of column names in the index\n   */\n  protected getIndexColumns(idx: unknown): string[] {\n    try {\n      const config = (idx as { config: { columns: Array<{ name?: string }> } }).config;\n      return config.columns\n        .map((c) => {\n          if (typeof c === \"object\" && c !== null && \"name\" in c) {\n            return c.name as string;\n          }\n          return \"\";\n        })\n        .filter(Boolean);\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Check if an index is unique\n   *\n   * @param idx - The index definition to check\n   * @returns True if the index has the unique flag\n   */\n  protected isUniqueIndex(idx: unknown): boolean {\n    try {\n      const config = (idx as { config: { unique?: boolean } }).config;\n      return config.unique === true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Get column names from a primary key constraint\n   *\n   * @param pk - The primary key definition to extract columns from\n   * @returns Array of column names in the primary key\n   */\n  protected getPrimaryKeyColumns(pk: unknown): string[] {\n    try {\n      const columns = (pk as { columns: Array<{ name: string }> }).columns;\n      return columns.map((c) => c.name);\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Get column names from a unique constraint\n   *\n   * @param uc - The unique constraint definition to extract columns from\n   * @returns Array of column names in the unique constraint\n   */\n  protected getUniqueConstraintColumns(uc: unknown): string[] {\n    try {\n      const columns = (uc as { columns: Array<{ name: string }> }).columns;\n      return columns.map((c) => c.name);\n    } catch {\n      return [];\n    }\n  }\n}\n\n/**\n * Write DBML content to a file\n *\n * Creates the directory if it doesn't exist and writes the DBML content\n * to the specified file path.\n *\n * @param filePath - The path to write the DBML file to\n * @param content - The DBML content to write\n */\nexport function writeDbmlFile(filePath: string, content: string): void {\n  const resolvedPath = resolve(filePath);\n  const dir = dirname(resolvedPath);\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(resolvedPath, content, \"utf-8\");\n}\n\n/**\n * Escape a string for use in DBML single-quoted strings\n *\n * Escapes backslashes, single quotes, and newlines for proper DBML formatting.\n *\n * @param str - The string to escape\n * @returns The escaped string safe for DBML\n */\nfunction escapeDbmlString(str: string): string {\n  return str.replace(/\\\\/g, \"\\\\\\\\\").replace(/'/g, \"\\\\'\").replace(/\\n/g, \"\\\\n\");\n}\n"],"names":["DbmlBuilder","content","indent","BaseGenerator","options","extractComments","extractRelations","dbml","tables","v0Relations","v1Entries","table","ref","value","is","PgTable","MySqlTable","SQLiteTable","relations","obj","relationValues","rel","Relation","entries","entry","values","v","tableName","getTableName","columns","getTableColumns","escapedName","column","tableConfig","tableComment","escapeDbmlString","config","getPgTableConfig","getMySqlTableConfig","getSqliteTableConfig","name","type","attrs","attrStr","defaultValue","columnComment","chunks","sqlParts","chunk","indexes","primaryKeys","uniqueConstraints","pk","colStr","c","uc","idx","foreignKeys","fk","fkObj","reference","fromColumns","toColumns","toTable","mapping","varName","tableVarName","propName","sourceTable","targetTable","sourceFields","targetReferences","relation","reverseFields","reverseReferences","a","b","val","i","tableNameMapping","processedRefs","parsedRelation","fromTableName","toTableName","fromColumnMapping","toColumnMapping","field","refKey","reverseRefKey","isOneToOne","sourceTableName","One","sourceColumns","col","targetColumns","targetTableName","fromEntry","e","relSourceCols","relTargetCols","referencedTable","fields","references","from","to","refLine","writeDbmlFile","filePath","resolvedPath","resolve","dir","dirname","mkdirSync","writeFileSync","str"],"mappings":"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"}

package/dist/generator/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * DBML Generator Module
+ *
+ * Provides functions to generate DBML from Drizzle ORM schema definitions.
+ * Supports PostgreSQL, MySQL, and SQLite dialects.
+ *
+ * JSDoc comments can be extracted from source files and included as DBML Note clauses.
+ * Use the `source` option to specify the schema source file or directory, or pass pre-extracted
+ * comments via the `comments` option.
+ */
+export { pgGenerate, PgGenerator } from './pg';
+export { mysqlGenerate, MySqlGenerator } from './mysql';
+export { sqliteGenerate, SqliteGenerator } from './sqlite';
+export { BaseGenerator, DbmlBuilder, writeDbmlFile } from './common';
+//# sourceMappingURL=index.d.ts.map

package/dist/generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/generator/mysql.d.ts

@@ -0,0 +1,36 @@
+import { BaseGenerator, DialectConfig } from './common';
+import { GenerateOptions } from '../types';
+/**
+ * MySQL-specific DBML generator
+ *
+ * Supports JSDoc comment extraction via `sourceFile` or `comments` options.
+ * Comments are included as DBML Note clauses for tables and columns.
+ */
+export declare class MySqlGenerator<TSchema extends Record<string, unknown> = Record<string, unknown>> extends BaseGenerator<TSchema> {
+    protected dialectConfig: DialectConfig;
+}
+/**
+ * Generate DBML from a MySQL Drizzle schema
+ *
+ * @example
+ * ```ts
+ * import { mysqlTable, serial, text, varchar } from "drizzle-orm/mysql-core";
+ * import { mysqlGenerate } from "drizzle-docs-generator";
+ *
+ * const users = mysqlTable("users", {
+ *   id: serial("id").primaryKey(),
+ *   name: text("name").notNull(),
+ *   email: varchar("email", { length: 255 }).unique(),
+ * });
+ *
+ * const dbml = mysqlGenerate({ schema: { users } });
+ * console.log(dbml);
+ * ```
+ *
+ * To include JSDoc comments as DBML Note clauses, use the `source` option:
+ * ```typescript
+ * const dbml = mysqlGenerate({ schema: { users }, source: "./schema.ts" });
+ * ```
+ */
+export declare function mysqlGenerate<TSchema extends Record<string, unknown>>(options: GenerateOptions<TSchema>): string;
+//# sourceMappingURL=mysql.d.ts.map

package/dist/generator/mysql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../src/generator/mysql.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAiB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,cAAc,CACzB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjE,SAAQ,aAAa,CAAC,OAAO,CAAC;IAC9B,SAAS,CAAC,aAAa,EAAE,aAAa,CAMpC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,GAChC,MAAM,CASR"}

package/dist/generator/mysql.js

@@ -0,0 +1,16 @@
+import { writeDbmlFile as n, BaseGenerator as a } from "./common.js";
+class o extends a {
+  dialectConfig = {
+    escapeName: (r) => `\`${r}\``,
+    isIncrement: (r) => r.autoIncrement === !0
+  };
+}
+function m(e) {
+  const t = new o(e).generate();
+  return e.out && n(e.out, t), t;
+}
+export {
+  o as MySqlGenerator,
+  m as mysqlGenerate
+};
+//# sourceMappingURL=mysql.js.map

package/dist/generator/mysql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.js","sources":["../../src/generator/mysql.ts"],"sourcesContent":["import type { AnyColumn } from \"drizzle-orm\";\nimport { BaseGenerator, writeDbmlFile, type DialectConfig } from \"./common\";\nimport type { GenerateOptions } from \"../types\";\n\n/**\n * MySQL-specific DBML generator\n *\n * Supports JSDoc comment extraction via `sourceFile` or `comments` options.\n * Comments are included as DBML Note clauses for tables and columns.\n */\nexport class MySqlGenerator<\n  TSchema extends Record<string, unknown> = Record<string, unknown>,\n> extends BaseGenerator<TSchema> {\n  protected dialectConfig: DialectConfig = {\n    escapeName: (name: string) => `\\`${name}\\``,\n    isIncrement: (column: AnyColumn) => {\n      // MySQL uses autoincrement property\n      return (column as unknown as { autoIncrement?: boolean }).autoIncrement === true;\n    },\n  };\n}\n\n/**\n * Generate DBML from a MySQL Drizzle schema\n *\n * @example\n * ```ts\n * import { mysqlTable, serial, text, varchar } from \"drizzle-orm/mysql-core\";\n * import { mysqlGenerate } from \"drizzle-docs-generator\";\n *\n * const users = mysqlTable(\"users\", {\n *   id: serial(\"id\").primaryKey(),\n *   name: text(\"name\").notNull(),\n *   email: varchar(\"email\", { length: 255 }).unique(),\n * });\n *\n * const dbml = mysqlGenerate({ schema: { users } });\n * console.log(dbml);\n * ```\n *\n * To include JSDoc comments as DBML Note clauses, use the `source` option:\n * ```typescript\n * const dbml = mysqlGenerate({ schema: { users }, source: \"./schema.ts\" });\n * ```\n */\nexport function mysqlGenerate<TSchema extends Record<string, unknown>>(\n  options: GenerateOptions<TSchema>,\n): string {\n  const generator = new MySqlGenerator(options);\n  const dbml = generator.generate();\n\n  if (options.out) {\n    writeDbmlFile(options.out, dbml);\n  }\n\n  return dbml;\n}\n"],"names":["MySqlGenerator","BaseGenerator","name","column","mysqlGenerate","options","dbml","writeDbmlFile"],"mappings":";AAUO,MAAMA,UAEHC,EAAuB;AAAA,EACrB,gBAA+B;AAAA,IACvC,YAAY,CAACC,MAAiB,KAAKA,CAAI;AAAA,IACvC,aAAa,CAACC,MAEJA,EAAkD,kBAAkB;AAAA,EAC9E;AAEJ;AAyBO,SAASC,EACdC,GACQ;AAER,QAAMC,IADY,IAAIN,EAAeK,CAAO,EACrB,SAAA;AAEvB,SAAIA,EAAQ,OACVE,EAAcF,EAAQ,KAAKC,CAAI,GAG1BA;AACT;"}

package/dist/generator/pg.d.ts

@@ -0,0 +1,48 @@
+import { BaseGenerator, DialectConfig } from './common';
+import { GenerateOptions } from '../types';
+/**
+ * PostgreSQL-specific DBML generator
+ *
+ * Supports JSDoc comment extraction via `sourceFile` or `comments` options.
+ * Comments are included as DBML Note clauses for tables and columns.
+ */
+export declare class PgGenerator<TSchema extends Record<string, unknown> = Record<string, unknown>> extends BaseGenerator<TSchema> {
+    protected dialectConfig: DialectConfig;
+    /**
+     * Generate DBML including PostgreSQL-specific constructs like enums
+     */
+    generate(): string;
+    /**
+     * Collect all enum types from the schema
+     */
+    private collectEnums;
+    /**
+     * Generate a PostgreSQL enum definition
+     */
+    private generateEnum;
+}
+/**
+ * Generate DBML from a PostgreSQL Drizzle schema
+ *
+ * @example
+ * ```ts
+ * import { pgTable, serial, text, varchar } from "drizzle-orm/pg-core";
+ * import { pgGenerate } from "drizzle-docs-generator";
+ *
+ * const users = pgTable("users", {
+ *   id: serial("id").primaryKey(),
+ *   name: text("name").notNull(),
+ *   email: varchar("email", { length: 255 }).unique(),
+ * });
+ *
+ * const dbml = pgGenerate({ schema: { users } });
+ * console.log(dbml);
+ * ```
+ *
+ * To include JSDoc comments as DBML Note clauses, use the `source` option:
+ * ```typescript
+ * const dbml = pgGenerate({ schema: { users }, source: "./schema.ts" });
+ * ```
+ */
+export declare function pgGenerate<TSchema extends Record<string, unknown>>(options: GenerateOptions<TSchema>): string;
+//# sourceMappingURL=pg.d.ts.map

package/dist/generator/pg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../../src/generator/pg.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAA8B,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AACzF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,WAAW,CACtB,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjE,SAAQ,aAAa,CAAC,OAAO,CAAC;IAC9B,SAAS,CAAC,aAAa,EAAE,aAAa,CAMpC;IAEF;;OAEG;IACM,QAAQ,IAAI,MAAM;IAmB3B;;OAEG;IACH,OAAO,CAAC,YAAY;IAsBpB;;OAEG;IACH,OAAO,CAAC,YAAY;CASrB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,GAChC,MAAM,CASR"}

package/dist/generator/pg.js

@@ -0,0 +1,52 @@
+import { getTableColumns as u } from "drizzle-orm";
+import { PgEnumColumn as l } from "drizzle-orm/pg-core";
+import { writeDbmlFile as c, BaseGenerator as m, DbmlBuilder as i } from "./common.js";
+class f extends m {
+  dialectConfig = {
+    escapeName: (e) => `"${e}"`,
+    isIncrement: (e) => e.getSQLType().toLowerCase().includes("serial")
+  };
+  /**
+   * Generate DBML including PostgreSQL-specific constructs like enums
+   */
+  generate() {
+    const e = new i(), n = this.collectEnums();
+    for (const [s, r] of n)
+      this.generateEnum(e, s, r), e.line();
+    const t = super.generate();
+    return t && e.line(t), e.build().trim();
+  }
+  /**
+   * Collect all enum types from the schema
+   */
+  collectEnums() {
+    const e = /* @__PURE__ */ new Map(), n = this.getTables();
+    for (const t of n) {
+      const s = u(t);
+      for (const r of Object.values(s))
+        if (r instanceof l) {
+          const a = r.enum;
+          a && !e.has(a.enumName) && e.set(a.enumName, a.enumValues);
+        }
+    }
+    return e;
+  }
+  /**
+   * Generate a PostgreSQL enum definition
+   */
+  generateEnum(e, n, t) {
+    e.line(`enum ${this.dialectConfig.escapeName(n)} {`), e.indent();
+    for (const s of t)
+      e.line(s);
+    e.dedent(), e.line("}");
+  }
+}
+function d(o) {
+  const n = new f(o).generate();
+  return o.out && c(o.out, n), n;
+}
+export {
+  f as PgGenerator,
+  d as pgGenerate
+};
+//# sourceMappingURL=pg.js.map

package/dist/generator/pg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.js","sources":["../../src/generator/pg.ts"],"sourcesContent":["import { type AnyColumn, getTableColumns } from \"drizzle-orm\";\nimport { PgEnumColumn } from \"drizzle-orm/pg-core\";\nimport { BaseGenerator, DbmlBuilder, writeDbmlFile, type DialectConfig } from \"./common\";\nimport type { GenerateOptions } from \"../types\";\n\n/**\n * PostgreSQL-specific DBML generator\n *\n * Supports JSDoc comment extraction via `sourceFile` or `comments` options.\n * Comments are included as DBML Note clauses for tables and columns.\n */\nexport class PgGenerator<\n  TSchema extends Record<string, unknown> = Record<string, unknown>,\n> extends BaseGenerator<TSchema> {\n  protected dialectConfig: DialectConfig = {\n    escapeName: (name: string) => `\"${name}\"`,\n    isIncrement: (column: AnyColumn) => {\n      const sqlType = column.getSQLType().toLowerCase();\n      return sqlType.includes(\"serial\");\n    },\n  };\n\n  /**\n   * Generate DBML including PostgreSQL-specific constructs like enums\n   */\n  override generate(): string {\n    const dbml = new DbmlBuilder();\n\n    // Generate enums first\n    const enums = this.collectEnums();\n    for (const [name, values] of enums) {\n      this.generateEnum(dbml, name, values);\n      dbml.line();\n    }\n\n    // Then generate tables and refs\n    const baseOutput = super.generate();\n    if (baseOutput) {\n      dbml.line(baseOutput);\n    }\n\n    return dbml.build().trim();\n  }\n\n  /**\n   * Collect all enum types from the schema\n   */\n  private collectEnums(): Map<string, string[]> {\n    const enums = new Map<string, string[]>();\n    const tables = this.getTables();\n\n    for (const table of tables) {\n      const columns = getTableColumns(table);\n\n      for (const column of Object.values(columns)) {\n        if (column instanceof PgEnumColumn) {\n          const enumObj = (\n            column as unknown as { enum: { enumName: string; enumValues: string[] } }\n          ).enum;\n          if (enumObj && !enums.has(enumObj.enumName)) {\n            enums.set(enumObj.enumName, enumObj.enumValues);\n          }\n        }\n      }\n    }\n\n    return enums;\n  }\n\n  /**\n   * Generate a PostgreSQL enum definition\n   */\n  private generateEnum(dbml: DbmlBuilder, name: string, values: string[]): void {\n    dbml.line(`enum ${this.dialectConfig.escapeName(name)} {`);\n    dbml.indent();\n    for (const value of values) {\n      dbml.line(value);\n    }\n    dbml.dedent();\n    dbml.line(\"}\");\n  }\n}\n\n/**\n * Generate DBML from a PostgreSQL Drizzle schema\n *\n * @example\n * ```ts\n * import { pgTable, serial, text, varchar } from \"drizzle-orm/pg-core\";\n * import { pgGenerate } from \"drizzle-docs-generator\";\n *\n * const users = pgTable(\"users\", {\n *   id: serial(\"id\").primaryKey(),\n *   name: text(\"name\").notNull(),\n *   email: varchar(\"email\", { length: 255 }).unique(),\n * });\n *\n * const dbml = pgGenerate({ schema: { users } });\n * console.log(dbml);\n * ```\n *\n * To include JSDoc comments as DBML Note clauses, use the `source` option:\n * ```typescript\n * const dbml = pgGenerate({ schema: { users }, source: \"./schema.ts\" });\n * ```\n */\nexport function pgGenerate<TSchema extends Record<string, unknown>>(\n  options: GenerateOptions<TSchema>,\n): string {\n  const generator = new PgGenerator(options);\n  const dbml = generator.generate();\n\n  if (options.out) {\n    writeDbmlFile(options.out, dbml);\n  }\n\n  return dbml;\n}\n"],"names":["PgGenerator","BaseGenerator","name","column","dbml","DbmlBuilder","enums","values","baseOutput","tables","table","columns","getTableColumns","PgEnumColumn","enumObj","value","pgGenerate","options","writeDbmlFile"],"mappings":";;;AAWO,MAAMA,UAEHC,EAAuB;AAAA,EACrB,gBAA+B;AAAA,IACvC,YAAY,CAACC,MAAiB,IAAIA,CAAI;AAAA,IACtC,aAAa,CAACC,MACIA,EAAO,WAAA,EAAa,YAAA,EACrB,SAAS,QAAQ;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA,EAMO,WAAmB;AAC1B,UAAMC,IAAO,IAAIC,EAAA,GAGXC,IAAQ,KAAK,aAAA;AACnB,eAAW,CAACJ,GAAMK,CAAM,KAAKD;AAC3B,WAAK,aAAaF,GAAMF,GAAMK,CAAM,GACpCH,EAAK,KAAA;AAIP,UAAMI,IAAa,MAAM,SAAA;AACzB,WAAIA,KACFJ,EAAK,KAAKI,CAAU,GAGfJ,EAAK,MAAA,EAAQ,KAAA;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA,EAKQ,eAAsC;AAC5C,UAAME,wBAAY,IAAA,GACZG,IAAS,KAAK,UAAA;AAEpB,eAAWC,KAASD,GAAQ;AAC1B,YAAME,IAAUC,EAAgBF,CAAK;AAErC,iBAAWP,KAAU,OAAO,OAAOQ,CAAO;AACxC,YAAIR,aAAkBU,GAAc;AAClC,gBAAMC,IACJX,EACA;AACF,UAAIW,KAAW,CAACR,EAAM,IAAIQ,EAAQ,QAAQ,KACxCR,EAAM,IAAIQ,EAAQ,UAAUA,EAAQ,UAAU;AAAA,QAElD;AAAA,IAEJ;AAEA,WAAOR;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAaF,GAAmBF,GAAcK,GAAwB;AAC5E,IAAAH,EAAK,KAAK,QAAQ,KAAK,cAAc,WAAWF,CAAI,CAAC,IAAI,GACzDE,EAAK,OAAA;AACL,eAAWW,KAASR;AAClB,MAAAH,EAAK,KAAKW,CAAK;AAEjB,IAAAX,EAAK,OAAA,GACLA,EAAK,KAAK,GAAG;AAAA,EACf;AACF;AAyBO,SAASY,EACdC,GACQ;AAER,QAAMb,IADY,IAAIJ,EAAYiB,CAAO,EAClB,SAAA;AAEvB,SAAIA,EAAQ,OACVC,EAAcD,EAAQ,KAAKb,CAAI,GAG1BA;AACT;"}

package/dist/generator/sqlite.d.ts

@@ -0,0 +1,36 @@
+import { BaseGenerator, DialectConfig } from './common';
+import { GenerateOptions } from '../types';
+/**
+ * SQLite-specific DBML generator
+ *
+ * Supports JSDoc comment extraction via `sourceFile` or `comments` options.
+ * Comments are included as DBML Note clauses for tables and columns.
+ */
+export declare class SqliteGenerator<TSchema extends Record<string, unknown> = Record<string, unknown>> extends BaseGenerator<TSchema> {
+    protected dialectConfig: DialectConfig;
+}
+/**
+ * Generate DBML from a SQLite Drizzle schema
+ *
+ * @example
+ * ```ts
+ * import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
+ * import { sqliteGenerate } from "drizzle-docs-generator";
+ *
+ * const users = sqliteTable("users", {
+ *   id: integer("id").primaryKey(),
+ *   name: text("name").notNull(),
+ *   email: text("email").unique(),
+ * });
+ *
+ * const dbml = sqliteGenerate({ schema: { users } });
+ * console.log(dbml);
+ * ```
+ *
+ * To include JSDoc comments as DBML Note clauses, use the `source` option:
+ * ```typescript
+ * const dbml = sqliteGenerate({ schema: { users }, source: "./schema.ts" });
+ * ```
+ */
+export declare function sqliteGenerate<TSchema extends Record<string, unknown>>(options: GenerateOptions<TSchema>): string;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/generator/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/generator/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAiB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;GAKG;AACH,qBAAa,eAAe,CAC1B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjE,SAAQ,aAAa,CAAC,OAAO,CAAC;IAC9B,SAAS,CAAC,aAAa,EAAE,aAAa,CAOpC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,GAChC,MAAM,CASR"}

package/dist/generator/sqlite.js

@@ -0,0 +1,16 @@
+import { writeDbmlFile as n, BaseGenerator as a } from "./common.js";
+class o extends a {
+  dialectConfig = {
+    escapeName: (e) => `"${e}"`,
+    isIncrement: (e) => e.getSQLType().toLowerCase() === "integer" && e.primary
+  };
+}
+function i(r) {
+  const t = new o(r).generate();
+  return r.out && n(r.out, t), t;
+}
+export {
+  o as SqliteGenerator,
+  i as sqliteGenerate
+};
+//# sourceMappingURL=sqlite.js.map

package/dist/generator/sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.js","sources":["../../src/generator/sqlite.ts"],"sourcesContent":["import type { AnyColumn } from \"drizzle-orm\";\nimport { BaseGenerator, writeDbmlFile, type DialectConfig } from \"./common\";\nimport type { GenerateOptions } from \"../types\";\n\n/**\n * SQLite-specific DBML generator\n *\n * Supports JSDoc comment extraction via `sourceFile` or `comments` options.\n * Comments are included as DBML Note clauses for tables and columns.\n */\nexport class SqliteGenerator<\n  TSchema extends Record<string, unknown> = Record<string, unknown>,\n> extends BaseGenerator<TSchema> {\n  protected dialectConfig: DialectConfig = {\n    escapeName: (name: string) => `\"${name}\"`,\n    isIncrement: (column: AnyColumn) => {\n      // SQLite uses INTEGER PRIMARY KEY for autoincrement\n      const sqlType = column.getSQLType().toLowerCase();\n      return sqlType === \"integer\" && column.primary;\n    },\n  };\n}\n\n/**\n * Generate DBML from a SQLite Drizzle schema\n *\n * @example\n * ```ts\n * import { sqliteTable, integer, text } from \"drizzle-orm/sqlite-core\";\n * import { sqliteGenerate } from \"drizzle-docs-generator\";\n *\n * const users = sqliteTable(\"users\", {\n *   id: integer(\"id\").primaryKey(),\n *   name: text(\"name\").notNull(),\n *   email: text(\"email\").unique(),\n * });\n *\n * const dbml = sqliteGenerate({ schema: { users } });\n * console.log(dbml);\n * ```\n *\n * To include JSDoc comments as DBML Note clauses, use the `source` option:\n * ```typescript\n * const dbml = sqliteGenerate({ schema: { users }, source: \"./schema.ts\" });\n * ```\n */\nexport function sqliteGenerate<TSchema extends Record<string, unknown>>(\n  options: GenerateOptions<TSchema>,\n): string {\n  const generator = new SqliteGenerator(options);\n  const dbml = generator.generate();\n\n  if (options.out) {\n    writeDbmlFile(options.out, dbml);\n  }\n\n  return dbml;\n}\n"],"names":["SqliteGenerator","BaseGenerator","name","column","sqliteGenerate","options","dbml","writeDbmlFile"],"mappings":";AAUO,MAAMA,UAEHC,EAAuB;AAAA,EACrB,gBAA+B;AAAA,IACvC,YAAY,CAACC,MAAiB,IAAIA,CAAI;AAAA,IACtC,aAAa,CAACC,MAEIA,EAAO,WAAA,EAAa,YAAA,MACjB,aAAaA,EAAO;AAAA,EACzC;AAEJ;AAyBO,SAASC,EACdC,GACQ;AAER,QAAMC,IADY,IAAIN,EAAgBK,CAAO,EACtB,SAAA;AAEvB,SAAIA,EAAQ,OACVE,EAAcF,EAAQ,KAAKC,CAAI,GAG1BA;AACT;"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * drizzle-docs-generator
+ *
+ * A CLI tool that generates DBML files from Drizzle ORM schema definitions.
+ *
+ * Supports extracting JSDoc comments from source files and including them
+ * as DBML Note clauses using the TypeScript Compiler API.
+ */
+export { extractComments } from './parser/index';
+export type { SchemaComments, TableComment, ColumnComment } from './parser/index';
+export { pgGenerate, PgGenerator, mysqlGenerate, MySqlGenerator, sqliteGenerate, SqliteGenerator, BaseGenerator, DbmlBuilder, writeDbmlFile, } from './generator/index';
+export type { GenerateOptions, GeneratedRef, ColumnAttributes, RelationType } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGlF,OAAO,EACL,UAAU,EACV,WAAW,EACX,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,aAAa,EACb,WAAW,EACX,aAAa,GACd,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+import { extractComments as a } from "./parser/comments.js";
+import "typescript";
+import "node:fs";
+import "node:path";
+import { PgGenerator as i, pgGenerate as l } from "./generator/pg.js";
+import { MySqlGenerator as G, mysqlGenerate as x } from "./generator/mysql.js";
+import { SqliteGenerator as q, sqliteGenerate as s } from "./generator/sqlite.js";
+import { BaseGenerator as g, DbmlBuilder as y, writeDbmlFile as B } from "./generator/common.js";
+export {
+  g as BaseGenerator,
+  y as DbmlBuilder,
+  G as MySqlGenerator,
+  i as PgGenerator,
+  q as SqliteGenerator,
+  a as extractComments,
+  x as mysqlGenerate,
+  l as pgGenerate,
+  s as sqliteGenerate,
+  B as writeDbmlFile
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/parser/comments.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Comments for a single column
+ */
+export interface ColumnComment {
+    comment: string;
+}
+/**
+ * Comments for a single table
+ */
+export interface TableComment {
+    comment?: string;
+    columns: Record<string, ColumnComment>;
+}
+/**
+ * All extracted comments from a schema file
+ */
+export interface SchemaComments {
+    tables: Record<string, TableComment>;
+}
+/**
+ * Extract JSDoc comments from a Drizzle schema source file or directory
+ *
+ * Parses TypeScript source files and extracts:
+ * - JSDoc comments on table definitions (e.g., pgTable, mysqlTable, sqliteTable)
+ * - JSDoc comments on column definitions within tables
+ *
+ * @param sourcePath - Path to the TypeScript schema file or directory
+ * @returns Extracted comments organized by table and column
+ */
+export declare function extractComments(sourcePath: string): SchemaComments;
+//# sourceMappingURL=comments.d.ts.map

package/dist/parser/comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../src/parser/comments.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACtC;AA+BD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAalE"}

package/dist/parser/comments.js

@@ -0,0 +1,113 @@
+import * as r from "typescript";
+import { readFileSync as g, statSync as b, readdirSync as C } from "node:fs";
+import { join as y } from "node:path";
+function p(t) {
+  const n = b(t);
+  if (n.isFile())
+    return t.endsWith(".ts") ? [t] : [];
+  if (n.isDirectory()) {
+    const i = [], o = C(t, { withFileTypes: !0 });
+    for (const e of o) {
+      const s = y(t, e.name);
+      e.isDirectory() ? i.push(...p(s)) : e.isFile() && e.name.endsWith(".ts") && !e.name.endsWith(".test.ts") && i.push(s);
+    }
+    return i;
+  }
+  return [];
+}
+function L(t) {
+  const n = { tables: {} }, i = p(t);
+  for (const o of i) {
+    const e = g(o, "utf-8"), s = r.createSourceFile(o, e, r.ScriptTarget.Latest, !0);
+    d(s, s, n);
+  }
+  return n;
+}
+function d(t, n, i) {
+  if (r.isVariableStatement(t)) {
+    const o = x(t, n);
+    for (const e of t.declarationList.declarations)
+      if (r.isIdentifier(e.name) && e.initializer && r.isCallExpression(e.initializer)) {
+        const s = h(
+          e.name.text,
+          e.initializer,
+          n,
+          o
+        );
+        s && (i.tables[s.tableName] = s.tableComment);
+      }
+  }
+  r.forEachChild(t, (o) => d(o, n, i));
+}
+function h(t, n, i, o) {
+  const e = T(n);
+  if (!S(e))
+    return;
+  const s = n.arguments[0];
+  if (!s || !r.isStringLiteral(s))
+    return;
+  const c = s.text, m = n.arguments[1], f = {};
+  if (m && r.isObjectLiteralExpression(m)) {
+    for (const a of m.properties)
+      if (r.isPropertyAssignment(a) && r.isIdentifier(a.name)) {
+        const l = v(a.initializer), u = x(a, i);
+        l && u && (f[l] = { comment: u });
+      }
+  }
+  return {
+    tableName: c,
+    tableComment: {
+      comment: o,
+      columns: f
+    }
+  };
+}
+function T(t) {
+  if (r.isIdentifier(t.expression))
+    return t.expression.text;
+  if (r.isPropertyAccessExpression(t.expression))
+    return t.expression.name.text;
+}
+function S(t) {
+  return t ? ["pgTable", "mysqlTable", "sqliteTable"].includes(t) : !1;
+}
+function v(t) {
+  let n = t;
+  for (; r.isCallExpression(n); )
+    if (r.isPropertyAccessExpression(n.expression))
+      n = n.expression.expression;
+    else if (r.isIdentifier(n.expression)) {
+      const i = n.arguments[0];
+      return i && r.isStringLiteral(i) ? i.text : void 0;
+    } else
+      return;
+}
+function x(t, n) {
+  const i = n.getFullText(), o = t.getFullStart(), e = r.getLeadingCommentRanges(i, o);
+  if (!(!e || e.length === 0)) {
+    for (const s of e) {
+      const c = i.slice(s.pos, s.end);
+      if (c.startsWith("/**"))
+        return D(c);
+    }
+    for (const s of e) {
+      const c = i.slice(s.pos, s.end);
+      if (c.startsWith("//"))
+        return c.slice(2).trim();
+    }
+  }
+}
+function D(t) {
+  const i = t.slice(3, -2).split(`
+`).map((e) => e.replace(/^\s*\*\s?/, "").trim()), o = [];
+  for (const e of i) {
+    if (e.startsWith("@"))
+      break;
+    o.push(e);
+  }
+  return o.join(" ").trim();
+}
+export {
+  L as extractComments
+};
+//# sourceMappingURL=comments.js.map

package/dist/parser/comments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comments.js","sources":["../../src/parser/comments.ts"],"sourcesContent":["import * as ts from \"typescript\";\nimport { readFileSync, statSync, readdirSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\n/**\n * Comments for a single column\n */\nexport interface ColumnComment {\n  comment: string;\n}\n\n/**\n * Comments for a single table\n */\nexport interface TableComment {\n  comment?: string;\n  columns: Record<string, ColumnComment>;\n}\n\n/**\n * All extracted comments from a schema file\n */\nexport interface SchemaComments {\n  tables: Record<string, TableComment>;\n}\n\n/**\n * Get all TypeScript files from a path (file or directory)\n */\nfunction getTypeScriptFiles(sourcePath: string): string[] {\n  const stat = statSync(sourcePath);\n\n  if (stat.isFile()) {\n    return sourcePath.endsWith(\".ts\") ? [sourcePath] : [];\n  }\n\n  if (stat.isDirectory()) {\n    const files: string[] = [];\n    const entries = readdirSync(sourcePath, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(sourcePath, entry.name);\n      if (entry.isDirectory()) {\n        files.push(...getTypeScriptFiles(fullPath));\n      } else if (entry.isFile() && entry.name.endsWith(\".ts\") && !entry.name.endsWith(\".test.ts\")) {\n        files.push(fullPath);\n      }\n    }\n\n    return files;\n  }\n\n  return [];\n}\n\n/**\n * Extract JSDoc comments from a Drizzle schema source file or directory\n *\n * Parses TypeScript source files and extracts:\n * - JSDoc comments on table definitions (e.g., pgTable, mysqlTable, sqliteTable)\n * - JSDoc comments on column definitions within tables\n *\n * @param sourcePath - Path to the TypeScript schema file or directory\n * @returns Extracted comments organized by table and column\n */\nexport function extractComments(sourcePath: string): SchemaComments {\n  const comments: SchemaComments = { tables: {} };\n  const files = getTypeScriptFiles(sourcePath);\n\n  for (const filePath of files) {\n    const sourceCode = readFileSync(filePath, \"utf-8\");\n    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);\n\n    // Visit all nodes in the source file\n    visitNode(sourceFile, sourceFile, comments);\n  }\n\n  return comments;\n}\n\n/**\n * Recursively visit AST nodes to find table and column definitions\n */\nfunction visitNode(node: ts.Node, sourceFile: ts.SourceFile, comments: SchemaComments): void {\n  // Look for variable declarations that define tables\n  if (ts.isVariableStatement(node)) {\n    const jsDocComment = getJsDocComment(node, sourceFile);\n\n    for (const declaration of node.declarationList.declarations) {\n      if (\n        ts.isIdentifier(declaration.name) &&\n        declaration.initializer &&\n        ts.isCallExpression(declaration.initializer)\n      ) {\n        const tableInfo = parseTableDefinition(\n          declaration.name.text,\n          declaration.initializer,\n          sourceFile,\n          jsDocComment,\n        );\n        if (tableInfo) {\n          comments.tables[tableInfo.tableName] = tableInfo.tableComment;\n        }\n      }\n    }\n  }\n\n  ts.forEachChild(node, (child) => visitNode(child, sourceFile, comments));\n}\n\n/**\n * Parse a table definition call expression (e.g., pgTable(\"users\", { ... }))\n */\nfunction parseTableDefinition(\n  _variableName: string,\n  callExpr: ts.CallExpression,\n  sourceFile: ts.SourceFile,\n  tableJsDoc: string | undefined,\n): { tableName: string; tableComment: TableComment } | undefined {\n  const funcName = getCallExpressionName(callExpr);\n\n  // Check if this is a table definition function\n  if (!isTableDefinitionFunction(funcName)) {\n    return undefined;\n  }\n\n  // Get table name from first argument\n  const tableNameArg = callExpr.arguments[0];\n  if (!tableNameArg || !ts.isStringLiteral(tableNameArg)) {\n    return undefined;\n  }\n  const tableName = tableNameArg.text;\n\n  // Get column definitions from second argument\n  const columnsArg = callExpr.arguments[1];\n  const columnComments: Record<string, ColumnComment> = {};\n\n  if (columnsArg && ts.isObjectLiteralExpression(columnsArg)) {\n    for (const property of columnsArg.properties) {\n      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {\n        const columnName = extractColumnName(property.initializer);\n        const columnJsDoc = getJsDocComment(property, sourceFile);\n\n        if (columnName && columnJsDoc) {\n          columnComments[columnName] = { comment: columnJsDoc };\n        }\n      }\n    }\n  }\n\n  return {\n    tableName,\n    tableComment: {\n      comment: tableJsDoc,\n      columns: columnComments,\n    },\n  };\n}\n\n/**\n * Get the function name from a call expression\n */\nfunction getCallExpressionName(callExpr: ts.CallExpression): string | undefined {\n  if (ts.isIdentifier(callExpr.expression)) {\n    return callExpr.expression.text;\n  }\n  if (ts.isPropertyAccessExpression(callExpr.expression)) {\n    return callExpr.expression.name.text;\n  }\n  return undefined;\n}\n\n/**\n * Check if a function name is a table definition function\n */\nfunction isTableDefinitionFunction(funcName: string | undefined): boolean {\n  if (!funcName) return false;\n  return [\"pgTable\", \"mysqlTable\", \"sqliteTable\"].includes(funcName);\n}\n\n/**\n * Extract the actual column name from a column definition\n * e.g., serial(\"id\") -> \"id\", text(\"name\") -> \"name\"\n */\nfunction extractColumnName(expr: ts.Expression): string | undefined {\n  // Handle chained calls like serial(\"id\").primaryKey()\n  let current = expr;\n\n  while (ts.isCallExpression(current)) {\n    if (ts.isPropertyAccessExpression(current.expression)) {\n      // This is a method call like .primaryKey(), go deeper\n      current = current.expression.expression;\n    } else if (ts.isIdentifier(current.expression)) {\n      // This is the base call like serial(\"id\")\n      const firstArg = current.arguments[0];\n      if (firstArg && ts.isStringLiteral(firstArg)) {\n        return firstArg.text;\n      }\n      return undefined;\n    } else {\n      return undefined;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Get JSDoc comment from a node\n */\nfunction getJsDocComment(node: ts.Node, sourceFile: ts.SourceFile): string | undefined {\n  const fullText = sourceFile.getFullText();\n  const nodeStart = node.getFullStart();\n  const leadingComments = ts.getLeadingCommentRanges(fullText, nodeStart);\n\n  if (!leadingComments || leadingComments.length === 0) {\n    return undefined;\n  }\n\n  // Find JSDoc comment (starts with /**)\n  for (const comment of leadingComments) {\n    const commentText = fullText.slice(comment.pos, comment.end);\n    if (commentText.startsWith(\"/**\")) {\n      return parseJsDocComment(commentText);\n    }\n  }\n\n  // Fall back to single-line comments\n  for (const comment of leadingComments) {\n    const commentText = fullText.slice(comment.pos, comment.end);\n    if (commentText.startsWith(\"//\")) {\n      return commentText.slice(2).trim();\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Parse JSDoc comment text to extract the description\n */\nfunction parseJsDocComment(commentText: string): string {\n  // Remove /** and */\n  let text = commentText.slice(3, -2);\n\n  // Split into lines and process\n  const lines = text.split(\"\\n\").map((line) => {\n    // Remove leading * and whitespace\n    return line.replace(/^\\s*\\*\\s?/, \"\").trim();\n  });\n\n  // Filter out @tags and empty lines at start/end\n  const contentLines: string[] = [];\n  for (const line of lines) {\n    // Stop at first @tag\n    if (line.startsWith(\"@\")) {\n      break;\n    }\n    contentLines.push(line);\n  }\n\n  // Join and trim\n  return contentLines.join(\" \").trim();\n}\n"],"names":["getTypeScriptFiles","sourcePath","stat","statSync","files","entries","readdirSync","entry","fullPath","join","extractComments","comments","filePath","sourceCode","readFileSync","sourceFile","ts","visitNode","node","jsDocComment","getJsDocComment","declaration","tableInfo","parseTableDefinition","child","_variableName","callExpr","tableJsDoc","funcName","getCallExpressionName","isTableDefinitionFunction","tableNameArg","tableName","columnsArg","columnComments","property","columnName","extractColumnName","columnJsDoc","expr","current","firstArg","fullText","nodeStart","leadingComments","comment","commentText","parseJsDocComment","lines","line","contentLines"],"mappings":"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"}