feat(domains): ✨ add domain support for DrawDB integration

- Introduce Domain and DomainTable models for logical grouping of tables.
- Implement export and import functionality for domains in DrawDB format.
- Update template execution modes to include domain processing.
- Enhance documentation for domain features and usage.

pkg/writers/drawdb/writer.go

@@ -127,6 +127,51 @@ func (w *Writer) databaseToDrawDB(d *models.Database) *DrawDBSchema {
 		}
 	}
 
+	// Create subject areas for domains
+	for domainIdx, domainModel := range d.Domains {
+		// Calculate bounds for all tables in this domain
+		minX, minY := 999999, 999999
+		maxX, maxY := 0, 0
+
+		domainTableCount := 0
+		for _, domainTable := range domainModel.Tables {
+			// Find the table in the schema to get its position
+			for _, t := range schema.Tables {
+				if t.Name == domainTable.TableName {
+					if t.X < minX {
+						minX = t.X
+					}
+					if t.Y < minY {
+						minY = t.Y
+					}
+					if t.X+colWidth > maxX {
+						maxX = t.X + colWidth
+					}
+					if t.Y+rowHeight > maxY {
+						maxY = t.Y + rowHeight
+					}
+					domainTableCount++
+					break
+				}
+			}
+		}
+
+		// Only create area if domain has tables in this schema
+		if domainTableCount > 0 {
+			area := &DrawDBArea{
+				ID:     areaID,
+				Name:   domainModel.Name,
+				Color:  getColorForIndex(len(d.Schemas) + domainIdx), // Use different colors than schemas
+				X:      minX - 20,
+				Y:      minY - 20,
+				Width:  maxX - minX + 40,
+				Height: maxY - minY + 40,
+			}
+			schema.SubjectAreas = append(schema.SubjectAreas, area)
+			areaID++
+		}
+	}
+
 	// Add relationships
 	for _, schemaModel := range d.Schemas {
 		for _, table := range schemaModel.Tables {

pkg/writers/template/template_data.go

@@ -7,6 +7,7 @@ type TemplateData struct {
 	// One of these will be populated based on execution mode
 	Database *models.Database
 	Schema   *models.Schema
+	Domain   *models.Domain
 	Script   *models.Script
 	Table    *models.Table
 
@@ -57,6 +58,15 @@ func NewSchemaData(schema *models.Schema, metadata map[string]interface{}) *Temp
 	}
 }
 
+// NewDomainData creates template data for domain mode
+func NewDomainData(domain *models.Domain, db *models.Database, metadata map[string]interface{}) *TemplateData {
+	return &TemplateData{
+		Domain:         domain,
+		ParentDatabase: db,
+		Metadata:       metadata,
+	}
+}
+
 // NewScriptData creates template data for script mode
 func NewScriptData(script *models.Script, schema *models.Schema, db *models.Database, metadata map[string]interface{}) *TemplateData {
 	return &TemplateData{
@@ -85,6 +95,9 @@ func (td *TemplateData) Name() string {
 	if td.Schema != nil {
 		return td.Schema.Name
 	}
+	if td.Domain != nil {
+		return td.Domain.Name
+	}
 	if td.Script != nil {
 		return td.Script.Name
 	}

pkg/writers/template/writer.go

@@ -20,6 +20,8 @@ const (
 	DatabaseMode EntrypointMode = "database"
 	// SchemaMode executes the template once per schema (multi-file output)
 	SchemaMode EntrypointMode = "schema"
+	// DomainMode executes the template once per domain (multi-file output)
+	DomainMode EntrypointMode = "domain"
 	// ScriptMode executes the template once per script (multi-file output)
 	ScriptMode EntrypointMode = "script"
 	// TableMode executes the template once per table (multi-file output)
@@ -80,6 +82,8 @@ func (w *Writer) WriteDatabase(db *models.Database) error {
 		return w.executeDatabaseMode(db)
 	case SchemaMode:
 		return w.executeSchemaMode(db)
+	case DomainMode:
+		return w.executeDomainMode(db)
 	case ScriptMode:
 		return w.executeScriptMode(db)
 	case TableMode:
@@ -143,6 +147,28 @@ func (w *Writer) executeSchemaMode(db *models.Database) error {
 	return nil
 }
 
+// executeDomainMode executes the template once per domain
+func (w *Writer) executeDomainMode(db *models.Database) error {
+	for _, domain := range db.Domains {
+		data := NewDomainData(domain, db, w.options.Metadata)
+		output, err := w.executeTemplate(data)
+		if err != nil {
+			return fmt.Errorf("failed to execute template for domain %s: %w", domain.Name, err)
+		}
+
+		filename, err := w.generateFilename(data)
+		if err != nil {
+			return fmt.Errorf("failed to generate filename for domain %s: %w", domain.Name, err)
+		}
+
+		if err := w.writeOutput(output, filename); err != nil {
+			return fmt.Errorf("failed to write output for domain %s: %w", domain.Name, err)
+		}
+	}
+
+	return nil
+}
+
 // executeScriptMode executes the template once per script
 func (w *Writer) executeScriptMode(db *models.Database) error {
 	for _, schema := range db.Schemas {