feat: Scala case class support (Doobie/Quill/Slick) as 11th format (v1.6.0)

- NEW: ScalaParser — parses case class definitions with Option[T], default values
- NEW: ScalaGenerator — produces case classes with Option[T] for nullable columns
- Format identifier: 'scala' in CLI, MCP, and convert API
- Sample fixture: fixtures/sample.scala
- 17 new tests (parsing, generation, cross-format: sql/prisma/ef)
- 270/270 tests passing
- Updated CLI format choices, MCP format list
- Bumped to v1.6.0

Author: Coding-Dev-Tools

fixtures/sample.scala

@@ -0,0 +1,19 @@
+import java.time.{Instant, LocalDate, LocalTime}
+import java.util.UUID
+
+case class User(
+    id: Int,
+    name: String,
+    email: String,
+    role: String = "viewer",
+    isActive: Boolean = true,
+    createdAt: Instant
+)
+
+case class Post(
+    id: Int,
+    title: String,
+    content: Option[String],
+    authorId: Int,
+    status: String = "draft"
+)

src/schemaforge/cli.py

@@ -13,7 +13,7 @@
 from .mcp_server import mcp_command
 
 # All supported format names (used for CLI choices and detection)
-_FORMATS = ["sql", "prisma", "drizzle", "typeorm", "django", "sqlalchemy", "alembic", "json_schema", "graphql", "ef"]
+_FORMATS = ["sql", "prisma", "drizzle", "typeorm", "django", "sqlalchemy", "alembic", "json_schema", "graphql", "ef", "scala"]
 
 
 @click.group()

src/schemaforge/convert.py

@@ -24,6 +24,8 @@
 from .generators.graphql_generator import GraphQLGenerator
 from .parsers.ef_parser import EntityFrameworkParser
 from .generators.ef_generator import EntityFrameworkGenerator
+from .parsers.scala_parser import ScalaParser
+from .generators.scala_generator import ScalaGenerator
 
 if TYPE_CHECKING:
     from .type_config import TypeConfig
@@ -40,6 +42,7 @@
     "json_schema": (JSONSchemaParser, JSONSchemaGenerator),
     "graphql": (GraphQLParser, GraphQLGenerator),
     "ef": (EntityFrameworkParser, EntityFrameworkGenerator),
+    "scala": (ScalaParser, ScalaGenerator),
 }
 
 

src/schemaforge/generators/scala_generator.py

@@ -0,0 +1,122 @@
+"""Generator: SchemaForge IR → Scala case class definitions.
+
+Generates Scala case classes suitable for use with Doobie, Quill,
+or Slick. Handles Option[T] for nullable columns.
+"""
+from __future__ import annotations
+
+from ..ir import Schema, Column, ColumnType
+from ._base import resolve_type
+
+
+class ScalaGenerator:
+    """Convert Schema IR to Scala case class definitions."""
+
+    _TYPE_MAP: dict[ColumnType, str] = {
+        ColumnType.STRING: "String",
+        ColumnType.INTEGER: "Int",
+        ColumnType.FLOAT: "Double",
+        ColumnType.BOOLEAN: "Boolean",
+        ColumnType.DATETIME: "Instant",
+        ColumnType.DATE: "LocalDate",
+        ColumnType.TIME: "LocalTime",
+        ColumnType.TEXT: "String",
+        ColumnType.BLOB: "Array[Byte]",
+        ColumnType.JSON: "String",
+        ColumnType.UUID: "UUID",
+        ColumnType.ENUM: "String",
+        ColumnType.DECIMAL: "BigDecimal",
+    }
+
+    def __init__(self, type_config=None):
+        """Initialize generator with optional type config."""
+        self.type_config = type_config
+
+    def generate(self, schema: Schema) -> str:
+        """Generate Scala case class definitions from schema IR."""
+        parts: list[str] = [
+            "// Auto-generated by SchemaForge",
+            "// https://github.com/Coding-Dev-Tools/schemaforge",
+            "",
+            "import java.time.{Instant, LocalDate, LocalTime}",
+            "import java.util.UUID",
+            "import scala.math.BigDecimal",
+            "",
+        ]
+
+        # Generate imports based on types used
+        needed_imports: set[str] = set()
+        for table in schema.tables:
+            for col in table.columns:
+                sa_type = resolve_type(col, self._TYPE_MAP)
+                if sa_type.startswith("java."):
+                    needed_imports.add(sa_type.rsplit(".", 1)[0])
+
+        if needed_imports:
+            needed_imports.discard("java.time")  # Already imported
+            needed_imports.discard("java.util")  # Already imported
+            for imp in sorted(needed_imports):
+                parts.append(f"import {imp}")
+
+        if needed_imports:
+            parts.append("")
+
+        for table in schema.tables:
+            parts.append(self._generate_case_class(table))
+
+        return "\n".join(parts)
+
+    def _generate_case_class(self, table) -> str:
+        """Generate a single case class."""
+        class_name = self._to_pascal(table.name)
+        lines: list[str] = []
+        lines.append(f"case class {class_name}(")
+
+        field_lines: list[str] = []
+        for col in table.columns:
+            field_lines.append(f"    {self._field_def(col)},")
+
+        if field_lines:
+            lines.append("\n".join(field_lines))
+        else:
+            lines.append("    // No fields")
+
+        lines.append(")")
+
+        return "\n".join(lines)
+
+    def _field_def(self, col: Column) -> str:
+        """Generate a case class field definition."""
+        sa_type = resolve_type(col, self._TYPE_MAP)
+
+        # Handle nullable → Option[T]
+        if col.nullable:
+            scala_type = f"Option[{sa_type}]"
+        else:
+            scala_type = sa_type
+
+        # Default value
+        default_str = ""
+        if col.default is not None:
+            if isinstance(col.default, bool):
+                default_str = f" = {str(col.default).lower()}"
+            elif isinstance(col.default, str) and col.default.startswith("fn:"):
+                fn_val = col.default[3:]
+                fn_upper = fn_val.upper().rstrip("()")
+                if fn_upper in ("CURRENT_TIMESTAMP", "NOW", "INSTANT_NOW"):
+                    default_str = " = java.time.Instant.now()"
+                elif fn_upper == "CURRENT_DATE":
+                    default_str = " = java.time.LocalDate.now()"
+                elif fn_upper == "UUID" or fn_upper == "RANDOM_UUID":
+                    default_str = " = java.util.UUID.randomUUID()"
+            elif isinstance(col.default, str):
+                default_str = f' = "{col.default}"'
+            elif isinstance(col.default, (int, float)):
+                default_str = f" = {col.default}"
+
+        return f"{col.name}: {scala_type}{default_str}"
+
+    def _to_pascal(self, name: str) -> str:
+        """Convert snake_case to PascalCase."""
+        parts = name.split("_")
+        return "".join(p.capitalize() for p in parts if p)

src/schemaforge/mcp_server.py

@@ -25,7 +25,7 @@
 
 
 # All supported formats
-_FORMATS = ["sql", "prisma", "drizzle", "typeorm", "django", "sqlalchemy", "alembic", "json_schema", "graphql", "ef"]
+_FORMATS = ["sql", "prisma", "drizzle", "typeorm", "django", "sqlalchemy", "alembic", "json_schema", "graphql", "ef", "scala"]
 _FORMAT_DESCRIPTIONS = {
     "sql": "SQL DDL (Data Definition Language)",
     "prisma": "Prisma schema",
@@ -37,6 +37,7 @@
     "json_schema": "JSON Schema (draft 2020-12)",
     "graphql": "GraphQL SDL (Schema Definition Language)",
     "ef": "Entity Framework Core entities (C#)",
+    "scala": "Scala case classes (Doobie/Quill/Slick)",
 }
 
 

src/schemaforge/parsers/scala_parser.py

@@ -0,0 +1,191 @@
+"""Parser: Scala case class definitions → SchemaForge IR.
+
+Parses Scala case class definitions suitable for Doobie, Quill,
+or Slick into the internal schema representation.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..ir import Schema, Table, Column, ColumnType
+
+
+# Regex: extract case class
+_CASE_CLASS_RE = re.compile(
+    r'(?:@(?:Entity|Table|Mapped)\s*(?:\([^)]*\))?\s*)?'
+    r'(?:case\s+)?class\s+(\w+)'
+    r'(?:\s*\(((?:[^()]|\([^()]*\))*)\))',
+    re.MULTILINE,
+)
+
+# Regex: extract field from case class parameter list
+_FIELD_RE = re.compile(
+    r'\s*(\w+)\s*:\s*([^=,]+)(?:\s*=\s*([^,]+))?\s*,?\s*'
+)
+
+# Map Scala types to ColumnType
+_SCALA_TYPE_MAP: dict[str, ColumnType] = {
+    "Int": ColumnType.INTEGER,
+    "Long": ColumnType.INTEGER,
+    "Short": ColumnType.INTEGER,
+    "Byte": ColumnType.INTEGER,
+    "BigInt": ColumnType.INTEGER,
+    "String": ColumnType.STRING,
+    "Boolean": ColumnType.BOOLEAN,
+    "Double": ColumnType.FLOAT,
+    "Float": ColumnType.FLOAT,
+    "BigDecimal": ColumnType.DECIMAL,
+    "java.math.BigDecimal": ColumnType.DECIMAL,
+    "Instant": ColumnType.DATETIME,
+    "java.time.Instant": ColumnType.DATETIME,
+    "LocalDateTime": ColumnType.DATETIME,
+    "java.time.LocalDateTime": ColumnType.DATETIME,
+    "OffsetDateTime": ColumnType.DATETIME,
+    "java.time.OffsetDateTime": ColumnType.DATETIME,
+    "ZonedDateTime": ColumnType.DATETIME,
+    "java.time.ZonedDateTime": ColumnType.DATETIME,
+    "LocalDate": ColumnType.DATE,
+    "java.time.LocalDate": ColumnType.DATE,
+    "LocalTime": ColumnType.TIME,
+    "java.time.LocalTime": ColumnType.TIME,
+    "UUID": ColumnType.UUID,
+    "java.util.UUID": ColumnType.UUID,
+    "java.util.Date": ColumnType.DATETIME,
+    "DateTime": ColumnType.DATETIME,
+    "org.joda.time.DateTime": ColumnType.DATETIME,
+    "org.joda.time.LocalDate": ColumnType.DATE,
+    "org.joda.time.LocalTime": ColumnType.TIME,
+}
+
+
+def _clean_scala_type(raw: str) -> tuple[str, bool]:
+    """Clean a Scala type string.
+
+    Returns (cleaned_type, is_optional) where is_optional is True for Option[T].
+    """
+    raw = raw.strip()
+    is_optional = False
+
+    # Handle Option[T]
+    if raw.startswith("Option["):
+        raw = raw[7:-1].strip()
+        is_optional = True
+
+    # Handle List[T], Seq[T], Vector[T]
+    for prefix in ("List[", "Seq[", "Vector[", "Set[", "List["):
+        if raw.startswith(prefix) and raw.endswith(">"):
+            raw = raw[len(prefix) : -1].strip()
+            break
+
+    return raw, is_optional
+
+
+def _parse_default(value_str: str) -> Any:
+    """Parse a Scala default value expression."""
+    val = value_str.strip().rstrip(",")
+
+    if val == "true":
+        return True
+    if val == "false":
+        return False
+    if val == "null" or val == "None":
+        return None
+
+    # Quoted strings
+    if (val.startswith('"') and val.endswith('"')) or \
+       (val.startswith('"""') and val.endswith('"""')):
+        inner = val.strip('"')
+        # Handle interpolation: s"..."
+        idx = inner.find("$")
+        if idx >= 0:
+            inner = inner[:idx]
+        return inner
+
+    # Integer
+    try:
+        return int(val)
+    except ValueError:
+        pass
+
+    # Float
+    try:
+        return float(val)
+    except ValueError:
+        pass
+
+    # Function defaults (e.g., java.time.Instant.now())
+    if "(" in val and val.endswith(")"):
+        fn_name = val.split("(")[0].split(".")[-1]
+        return f"fn:{fn_name}()"
+
+    return None
+
+
+class ScalaParser:
+    """Parse Scala case class definitions into Schema IR."""
+
+    def parse(self, text: str) -> Schema:
+        """Parse Scala source text into a Schema IR."""
+        schema = Schema()
+
+        # Remove comments
+        text = re.sub(r"//.*$", "", text, flags=re.MULTILINE)
+        text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
+
+        for m in _CASE_CLASS_RE.finditer(text):
+            class_name = m.group(1)
+            params_str = m.group(2)
+
+            if not class_name or not params_str:
+                continue
+
+            table = Table(name=self._to_snake(class_name))
+            fields = _FIELD_RE.findall(params_str)
+
+            for field_name, field_type, default_str in fields:
+                col = self._field_to_column(field_name, field_type.strip(), default_str.strip())
+                if col:
+                    table.columns.append(col)
+
+            if table.columns:
+                schema.tables.append(table)
+
+        return schema
+
+    def _field_to_column(self, name: str, raw_type: str, default_str: str) -> Column | None:
+        """Convert a Scala field to a Column IR."""
+        clean_type, is_optional = _clean_scala_type(raw_type)
+
+        col_type = _SCALA_TYPE_MAP.get(clean_type, ColumnType.CUSTOM)
+        type_args: dict[str, Any] = {}
+        default_val: Any = None
+        custom_type = ""
+
+        # Parse default value
+        if default_str:
+            default_val = _parse_default(default_str)
+
+        # Handle String length from default values / heuristics
+        if col_type == ColumnType.STRING and isinstance(default_val, str):
+            pass  # No length hint from Scala
+
+        if col_type == ColumnType.CUSTOM:
+            custom_type = clean_type
+
+        return Column(
+            name=name,
+            type=col_type,
+            type_args=type_args,
+            nullable=is_optional,
+            unique=False,
+            primary_key=False,
+            default=default_val,
+            custom_type=custom_type,
+        )
+
+    def _to_snake(self, name: str) -> str:
+        """Convert PascalCase to snake_case."""
+        result = re.sub(r"([A-Z])", r"_\1", name).lower().lstrip("_")
+        result = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", result).lower()
+        return result.strip("_")