Add Drizzle ORM code generation module

FEATURE: Add TypeScript Drizzle ORM schema generation from PostgreSQL tables

Implements a new code generator in crates/codegen/src/drizzle/ that
produces idiomatic Drizzle ORM schema definitions from PostgreSQL
table snapshots. Follows the same architecture as the existing Python
(SQLModel) and Rust (SeaORM) generators.

Supports:
- pgTable definitions with all common PG types mapped to Drizzle builders
- Single-file (schema.ts) and multi-file (per-table + index.ts) output
- camelCase column names with explicit DB column name passthrough
- Composite primary keys and unique constraints via pgTable third arg
- Foreign key references via .references() chain
- Optional relations() generation for one-to-many/many-to-one
- Non-public schema support via pgSchema
- JavaScript reserved word handling

Includes comprehensive unit tests and insta snapshot tests covering
simple tables, blog schemas with relations, composite PKs, all PG
types, reserved words, multi-file output, self-referential FKs,
snake_case mode, and non-public schemas.

https://claude.ai/code/session_01EqR9j4R6jsTQbgCVLoFBZX

Author: claude

crates/codegen/src/drizzle/column.rs

@@ -0,0 +1,239 @@
+//! Import management for Drizzle ORM code generation.
+//!
+//! This module handles collecting and organizing TypeScript imports for generated code.
+//! All column builder imports come from `drizzle-orm/pg-core`, while relation helpers
+//! come from `drizzle-orm`.
+
+use std::collections::BTreeSet;
+
+/// Collects and organizes TypeScript imports for Drizzle code generation.
+#[derive(Debug, Default, Clone)]
+pub struct ImportCollector {
+    /// Imports from "drizzle-orm/pg-core" (pgTable, serial, text, etc.).
+    pg_core: BTreeSet<String>,
+    /// Imports from "drizzle-orm" (relations, etc.).
+    drizzle_orm: BTreeSet<String>,
+}
+
+impl ImportCollector {
+    /// Creates a new empty import collector.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Adds a "drizzle-orm/pg-core" import.
+    pub fn add_pg_core(&mut self, name: &str) {
+        self.pg_core.insert(name.to_string());
+    }
+
+    /// Adds multiple "drizzle-orm/pg-core" imports.
+    pub fn add_pg_core_all(&mut self, names: &[String]) {
+        for name in names {
+            self.pg_core.insert(name.clone());
+        }
+    }
+
+    /// Adds a "drizzle-orm" import.
+    pub fn add_drizzle_orm(&mut self, name: &str) {
+        self.drizzle_orm.insert(name.to_string());
+    }
+
+    /// Adds the pgTable import.
+    pub fn add_pg_table(&mut self) {
+        self.add_pg_core("pgTable");
+    }
+
+    /// Adds the pgSchema import.
+    pub fn add_pg_schema(&mut self) {
+        self.add_pg_core("pgSchema");
+    }
+
+    /// Adds the primaryKey import (for composite PKs).
+    pub fn add_primary_key(&mut self) {
+        self.add_pg_core("primaryKey");
+    }
+
+    /// Adds the unique import (for composite unique constraints).
+    pub fn add_unique(&mut self) {
+        self.add_pg_core("unique");
+    }
+
+    /// Adds the index import.
+    pub fn add_index(&mut self) {
+        self.add_pg_core("index");
+    }
+
+    /// Adds the relations import.
+    pub fn add_relations(&mut self) {
+        self.add_drizzle_orm("relations");
+    }
+
+    /// Merges another ImportCollector into this one.
+    pub fn merge(&mut self, other: &ImportCollector) {
+        self.pg_core.extend(other.pg_core.iter().cloned());
+        self.drizzle_orm.extend(other.drizzle_orm.iter().cloned());
+    }
+
+    /// Generates the import statements as formatted TypeScript code.
+    pub fn generate(&self) -> String {
+        let mut lines = Vec::new();
+
+        if !self.pg_core.is_empty() {
+            let names: Vec<&str> = self.pg_core.iter().map(|s| s.as_str()).collect();
+            lines.push(format_import_line(&names, "drizzle-orm/pg-core"));
+        }
+
+        if !self.drizzle_orm.is_empty() {
+            let names: Vec<&str> = self.drizzle_orm.iter().map(|s| s.as_str()).collect();
+            lines.push(format_import_line(&names, "drizzle-orm"));
+        }
+
+        lines.join("\n")
+    }
+
+    /// Returns true if there are no imports.
+    pub fn is_empty(&self) -> bool {
+        self.pg_core.is_empty() && self.drizzle_orm.is_empty()
+    }
+}
+
+/// Formats a single import line.
+fn format_import_line(names: &[&str], module: &str) -> String {
+    let joined = names.join(", ");
+    let single_line = format!("import {{ {joined} }} from \"{module}\";");
+
+    if single_line.len() <= 100 {
+        single_line
+    } else {
+        // Multi-line format
+        let mut lines = vec![format!("import {{")];
+        for name in names {
+            lines.push(format!("  {name},"));
+        }
+        lines.push(format!("}} from \"{module}\";"));
+        lines.join("\n")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_empty_collector() {
+        let collector = ImportCollector::new();
+        assert!(collector.is_empty());
+        assert_eq!(collector.generate(), "");
+    }
+
+    #[test]
+    fn test_pg_core_imports() {
+        let mut collector = ImportCollector::new();
+        collector.add_pg_table();
+        collector.add_pg_core("serial");
+        collector.add_pg_core("text");
+
+        let output = collector.generate();
+        assert!(output.contains("import {"));
+        assert!(output.contains("pgTable"));
+        assert!(output.contains("serial"));
+        assert!(output.contains("text"));
+        assert!(output.contains("drizzle-orm/pg-core"));
+    }
+
+    #[test]
+    fn test_drizzle_orm_imports() {
+        let mut collector = ImportCollector::new();
+        collector.add_relations();
+
+        let output = collector.generate();
+        assert!(output.contains("relations"));
+        assert!(output.contains("drizzle-orm"));
+        assert!(!output.contains("pg-core"));
+    }
+
+    #[test]
+    fn test_both_import_sources() {
+        let mut collector = ImportCollector::new();
+        collector.add_pg_table();
+        collector.add_pg_core("text");
+        collector.add_relations();
+
+        let output = collector.generate();
+        // pg-core line should come first (alphabetical order of module path)
+        let pg_core_pos = output.find("drizzle-orm/pg-core").unwrap();
+        let drizzle_pos = output
+            .find("\"drizzle-orm\"")
+            .or_else(|| output.find("from \"drizzle-orm\""))
+            .unwrap();
+        assert!(pg_core_pos < drizzle_pos);
+    }
+
+    #[test]
+    fn test_deterministic_ordering() {
+        for _ in 0..5 {
+            let mut collector = ImportCollector::new();
+            collector.add_pg_core("varchar");
+            collector.add_pg_core("text");
+            collector.add_pg_core("serial");
+            collector.add_pg_core("integer");
+            collector.add_pg_table();
+
+            let output = collector.generate();
+            // BTreeSet ensures alphabetical order
+            let integer_pos = output.find("integer").unwrap();
+            let pg_table_pos = output.find("pgTable").unwrap();
+            let serial_pos = output.find("serial").unwrap();
+            let text_pos = output.find("text").unwrap();
+            let varchar_pos = output.find("varchar").unwrap();
+
+            assert!(integer_pos < pg_table_pos);
+            assert!(pg_table_pos < serial_pos);
+            assert!(serial_pos < text_pos);
+            assert!(text_pos < varchar_pos);
+        }
+    }
+
+    #[test]
+    fn test_merge_collectors() {
+        let mut c1 = ImportCollector::new();
+        c1.add_pg_core("text");
+        c1.add_pg_table();
+
+        let mut c2 = ImportCollector::new();
+        c2.add_pg_core("integer");
+        c2.add_relations();
+
+        c1.merge(&c2);
+
+        let output = c1.generate();
+        assert!(output.contains("text"));
+        assert!(output.contains("integer"));
+        assert!(output.contains("pgTable"));
+        assert!(output.contains("relations"));
+    }
+
+    #[test]
+    fn test_deduplication() {
+        let mut collector = ImportCollector::new();
+        collector.add_pg_core("text");
+        collector.add_pg_core("text");
+        collector.add_pg_core("text");
+
+        let output = collector.generate();
+        // "text" should appear only once in the import
+        let count = output.matches("text").count();
+        assert_eq!(count, 1);
+    }
+
+    #[test]
+    fn test_add_pg_core_all() {
+        let mut collector = ImportCollector::new();
+        collector.add_pg_core_all(&["text".to_string(), "integer".to_string()]);
+
+        assert!(!collector.is_empty());
+        let output = collector.generate();
+        assert!(output.contains("text"));
+        assert!(output.contains("integer"));
+    }
+}

crates/codegen/src/drizzle/generator.rs

@@ -0,0 +1,108 @@
+//! Drizzle ORM code generation module.
+//!
+//! This module provides code generation for TypeScript Drizzle ORM schema
+//! definitions from PostgreSQL table definitions. It supports:
+//!
+//! - Idiomatic Drizzle `pgTable` definitions with proper type mappings
+//! - Primary keys (single and composite), foreign keys, unique constraints
+//! - Optional relation generation via `relations()` calls
+//! - camelCase or snake_case column naming with explicit DB column names
+//! - Non-public schema support via `pgSchema`
+//!
+//! # Example
+//!
+//! ```ignore
+//! use tern_codegen::{Codegen, drizzle::DrizzleCodegen};
+//!
+//! let codegen = DrizzleCodegen::new(DrizzleCodegenConfig::default());
+//! let output = codegen.generate(tables);
+//! // output contains "schema.ts" with Drizzle table definitions
+//! ```
+
+mod column;
+mod generator;
+mod imports;
+mod naming;
+mod table;
+mod type_mapping;
+
+#[cfg(test)]
+mod tests;
+
+pub use generator::DrizzleCodegen;
+
+use std::fmt;
+
+/// Configuration for Drizzle ORM code generation.
+#[derive(Debug, Clone)]
+pub struct DrizzleCodegenConfig {
+    /// Output mode: single file or multiple files.
+    pub output_mode: OutputMode,
+
+    /// Whether to generate Drizzle `relations()` calls for foreign keys.
+    pub generate_relations: bool,
+
+    /// Whether to use camelCase for column variable names.
+    ///
+    /// When true (default), column names like `user_id` become `userId` in the
+    /// generated code, with the original DB name passed to the builder:
+    /// `integer("user_id")`.
+    ///
+    /// When false, column names are kept as-is: `user_id: integer("user_id")`.
+    pub camel_case_columns: bool,
+
+    /// Optional schema name for non-public schemas.
+    ///
+    /// When set, uses `pgSchema` instead of `pgTable`:
+    /// ```ignore
+    /// const mySchema = pgSchema("myschema");
+    /// export const users = mySchema.table("users", { ... });
+    /// ```
+    pub schema_name: Option<String>,
+}
+
+impl Default for DrizzleCodegenConfig {
+    fn default() -> Self {
+        Self {
+            output_mode: OutputMode::default(),
+            generate_relations: false,
+            camel_case_columns: true,
+            schema_name: None,
+        }
+    }
+}
+
+/// Output mode for generated code.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub enum OutputMode {
+    /// Generate all table definitions in a single `schema.ts` file.
+    #[default]
+    SingleFile,
+    /// Generate separate files per table with an `index.ts` barrel export.
+    MultiFile,
+}
+
+impl fmt::Display for OutputMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::SingleFile => write!(f, "single_file"),
+            Self::MultiFile => write!(f, "multi_file"),
+        }
+    }
+}
+
+/// Errors that can occur during Drizzle code generation.
+#[derive(Debug, thiserror::Error)]
+pub enum DrizzleCodegenError {
+    /// An unsupported PostgreSQL type was encountered.
+    #[error("unsupported PostgreSQL type: {0}")]
+    UnsupportedType(String),
+
+    /// A table has no columns.
+    #[error("table has no columns: {0}")]
+    EmptyTable(String),
+
+    /// Code generation failed.
+    #[error("code generation failed: {0}")]
+    GenerationError(String),
+}