modelable 1.0.0__tar.gz → 1.0.2__tar.gz

{modelable-1.0.0 → modelable-1.0.2}/.gitignore

@@ -5,6 +5,7 @@ target/
 node_modules/
 dist/
 .modelable/
+site/
 
 # Helm fetched chart dependencies — regenerated by `helm dependency update`
 charts/*/charts/

{modelable-1.0.0 → modelable-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelable
-Version: 1.0.0
+Version: 1.0.2
 Summary: Compiler and language server for versioned, domain-owned data models
 Project-URL: Homepage, https://github.com/ktjn/modelable
 Project-URL: Documentation, https://github.com/ktjn/modelable/tree/main/docs

{modelable-1.0.0 → modelable-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modelable"
-version = "1.0.0"
+version = "1.0.2"
 description = "Compiler and language server for versioned, domain-owned data models"
 readme = "README.md"
 license = "Apache-2.0"

{modelable-1.0.0 → modelable-1.0.2}/src/modelable/commands/spec.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import os
+import time
 from dataclasses import asdict
 from pathlib import Path
 
@@ -70,25 +71,44 @@ def add(
 @click.option("--path", "workspace_path", type=click.Path(exists=True, path_type=Path), default=Path("."))
 @click.option("--json", "json_output", is_flag=True, help="Print machine-readable JSON.")
 @click.option("--fail-on", default="", help="Comma-separated statuses that should return a non-zero exit code.")
-def status(workspace_path: Path, json_output: bool, fail_on: str) -> None:
+@click.option("--poll-interval", default=None, type=float, help="Re-check every N seconds (useful in CI watch mode).")
+@click.option("--max-polls", default=None, type=int, help="Stop after this many checks when --poll-interval is set.")
+def status(
+    workspace_path: Path,
+    json_output: bool,
+    fail_on: str,
+    poll_interval: float | None,
+    max_polls: int | None,
+) -> None:
     """Report drift status for tracked external specifications."""
     token = os.getenv("MODELABLE_SPEC_TOKEN")
-    entries = select_specs(workspace_path, None)
-    evaluations = [evaluate_spec(workspace_path, entry, write=False, token=token) for entry in entries]
-    payload = {"specs": [evaluation.as_status_dict() for evaluation in evaluations]}
-    if json_output:
-        click.echo(json.dumps(payload, indent=2, sort_keys=True))
-    else:
-        if not evaluations:
-            console.print(f"[yellow]No tracked specs in {spec_config_path(workspace_path)}[/yellow]")
-        for evaluation in evaluations:
-            suffix = ""
-            if evaluation.change_kind:
-                suffix = f" ({evaluation.change_kind}, {evaluation.change_count} change(s))"
-            if evaluation.error:
-                suffix = f" ({evaluation.error})"
-            console.print(f"{evaluation.entry.id}: {evaluation.status}{suffix}")
     fail_statuses = {item.strip() for item in fail_on.split(",") if item.strip()}
+    polls = 0
+
+    while True:
+        entries = select_specs(workspace_path, None)
+        evaluations = [evaluate_spec(workspace_path, entry, write=False, token=token) for entry in entries]
+        payload = {"specs": [evaluation.as_status_dict() for evaluation in evaluations]}
+        if json_output:
+            click.echo(json.dumps(payload, indent=2, sort_keys=True))
+        else:
+            if not evaluations:
+                console.print(f"[yellow]No tracked specs in {spec_config_path(workspace_path)}[/yellow]")
+            for evaluation in evaluations:
+                suffix = ""
+                if evaluation.change_kind:
+                    suffix = f" ({evaluation.change_kind}, {evaluation.change_count} change(s))"
+                if evaluation.error:
+                    suffix = f" ({evaluation.error})"
+                console.print(f"{evaluation.entry.id}: {evaluation.status}{suffix}")
+
+        polls += 1
+        if poll_interval is None:
+            break
+        if max_polls is not None and polls >= max_polls:
+            break
+        time.sleep(poll_interval)
+
     if fail_statuses and any(evaluation.status in fail_statuses for evaluation in evaluations):
         raise click.ClickException("tracked spec status matched --fail-on")
 

{modelable-1.0.0 → modelable-1.0.2}/src/modelable/emitters/rust.py

@@ -7,9 +7,18 @@ from pathlib import Path
 
 from modelable.compiler.workspace import Workspace
 from modelable.emitters.base import EmittedArtifact, compute_content_hash
-from modelable.emitters.diagnostics import type_loss
+from modelable.emitters.diagnostics import missing_metadata, type_loss
 from modelable.emitters.shapes import TypeShape
-from modelable.parser.ir import DirectMapping, DomainDef, MdlFile, ModelVersion, ProjectionVersion
+from modelable.parser.ir import (
+    ArrayType,
+    DirectMapping,
+    DomainDef,
+    MapType,
+    MdlFile,
+    ModelVersion,
+    NamedType,
+    ProjectionVersion,
+)
 from modelable.registry.resolver import resolve_model_ref
 
 
@@ -22,15 +31,89 @@ class _FieldSpec:
     serde_attrs: list[str] = dc_field(default_factory=list)
 
 
+def _append_cross_enum_from_impls(
+    artifacts: list[EmittedArtifact],
+    enum_registry: dict[str, dict],
+) -> list[EmittedArtifact]:
+    """For each pair of enum types with identical variants in the same domain,
+    append From impl blocks into projection files without manual match arms.
+    """
+    # Group by domain: domain -> [(artifact_id, module_name, enums_dict, kind)]
+    by_domain: dict[str, list[tuple[str, str, dict[str, list[str]], str]]] = {}
+    for art_id, info in enum_registry.items():
+        domain = info["domain"]
+        by_domain.setdefault(domain, []).append((art_id, info["module_name"], info["enums"], info["kind"]))
+
+    # Build: frozenset(raw_variants) -> [(artifact_id, module_name, enum_type_name)]
+    # Per domain — From impls only work within the same Rust module tree (super:: path).
+    extra: dict[str, list[str]] = {}  # artifact_id -> lines to append
+    for _domain, entries in by_domain.items():
+        variant_map: dict[frozenset, list[tuple[str, str, str, str]]] = {}
+        for art_id, module_name, enums, kind in entries:
+            for enum_type_name, raw_variants in enums.items():
+                key = frozenset(raw_variants)
+                variant_map.setdefault(key, []).append((art_id, module_name, enum_type_name, kind))
+
+        for variant_set, enum_list in variant_map.items():
+            if len(enum_list) < 2:
+                continue
+            sorted_variants = sorted(variant_set)
+            # For each ordered pair (src → tgt): put From<src> for tgt in tgt's file.
+            for src_art_id, src_module, src_enum, _src_kind in enum_list:
+                for tgt_art_id, _tgt_module, tgt_enum, tgt_kind in enum_list:
+                    if src_art_id == tgt_art_id and src_enum == tgt_enum:
+                        continue
+                    if tgt_kind == "model":
+                        continue
+                    lines: list[str] = [
+                        "",
+                        f"use super::{src_module}::{src_enum};",
+                        f"impl From<{src_enum}> for {tgt_enum} {{",
+                        f"    fn from(src: {src_enum}) -> Self {{",
+                        "        match src {",
+                    ]
+                    for raw_v in sorted_variants:
+                        member = _enum_member_name(raw_v)
+                        lines.append(f"            {src_enum}::{member} => {tgt_enum}::{member},")
+                    lines += ["        }", "    }", "}"]
+                    extra.setdefault(tgt_art_id, []).extend(lines)
+
+    if not extra:
+        return artifacts
+
+    result: list[EmittedArtifact] = []
+    for artifact in artifacts:
+        appendage = extra.get(artifact.artifact_id)
+        if appendage:
+            new_content = artifact.content.rstrip("\n") + "\n" + "\n".join(appendage) + "\n"
+            result.append(
+                EmittedArtifact(
+                    target=artifact.target,
+                    ref=artifact.ref,
+                    artifact_id=artifact.artifact_id,
+                    path=artifact.path,
+                    content=new_content,
+                    content_hash=compute_content_hash(new_content),
+                    warnings=artifact.warnings,
+                )
+            )
+        else:
+            result.append(artifact)
+    return result
+
+
 def emit_rust(workspace: Workspace, out_dir: Path) -> list[EmittedArtifact]:
     """Emit Rust source files for every model and projection version."""
     postgres_sources = _adapter_bound_sources(workspace.mdl, "postgres")
     clickhouse_sources = _adapter_bound_sources(workspace.mdl, "clickhouse")
+    enum_registry: dict[str, dict] = {}
     artifacts: list[EmittedArtifact] = []
     for domain in workspace.mdl.domains:
         for model_name, versions in domain.models.items():
             for version in versions:
-                artifacts.append(_emit_model(domain, model_name, version, out_dir))
+                artifacts.append(
+                    _emit_model(domain, model_name, version, out_dir, enum_registry=enum_registry, mdl=workspace.mdl)
+                )
         for projection_name, versions in domain.projections.items():
             for version in versions:
                 source = version.source.model
@@ -43,9 +126,10 @@ def emit_rust(workspace: Workspace, out_dir: Path) -> list[EmittedArtifact]:
                         workspace.mdl,
                         sqlx_fromrow=source in postgres_sources,
                         clickhouse_row=source in clickhouse_sources,
+                        enum_registry=enum_registry,
                     )
                 )
-    return artifacts
+    return _append_cross_enum_from_impls(artifacts, enum_registry)
 
 
 def _adapter_bound_sources(mdl: MdlFile, adapter_type: str) -> set[str]:
@@ -86,18 +170,87 @@ def _stable_type_name(domain: str, name: str, version: int) -> str:
     return f"{_pascalize(domain)}{_pascalize(name)}V{version}"
 
 
-def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_dir: Path) -> EmittedArtifact:
+def _collect_named_type_refs(field_type, result: set) -> None:
+    """Recursively collect NamedType names from a field type."""
+    if isinstance(field_type, NamedType):
+        result.add(field_type.name)
+    elif isinstance(field_type, ArrayType):
+        _collect_named_type_refs(field_type.item, result)
+    elif isinstance(field_type, MapType):
+        _collect_named_type_refs(field_type.key, result)
+        _collect_named_type_refs(field_type.value, result)
+
+
+def _resolve_named_type_map(named_refs: set, mdl: MdlFile | None) -> tuple[dict[str, str], list[str]]:
+    """Resolve NamedType references to Rust type names from the workspace.
+
+    Returns (name -> rust_type_name, list of use statements).
+    """
+    if not named_refs or mdl is None:
+        return {}, []
+    resolved_map: dict[str, str] = {}
+    use_statements: list[str] = []
+    for name in named_refs:
+        for domain in mdl.domains:
+            if name in domain.models:
+                versions = domain.models[name]
+                if versions:
+                    latest = versions[-1]
+                    rust_name = _stable_type_name(domain.name, name, latest.version)
+                    module = _snake_case(rust_name)
+                    resolved_map[name] = rust_name
+                    use_statements.append(f"use super::{module}::{rust_name};")
+                    break
+    return resolved_map, use_statements
+
+
+def _emit_model(
+    domain: DomainDef,
+    model_name: str,
+    version: ModelVersion,
+    out_dir: Path,
+    *,
+    enum_registry: dict[str, dict] | None = None,
+    mdl: MdlFile | None = None,
+) -> EmittedArtifact:
     artifact_id = _artifact_id(domain.name, model_name, version.version)
     type_name = _stable_type_name(domain.name, model_name, version.version)
     nested_definitions: dict[str, list[str]] = {}
+    local_enum_info: dict[str, list[str]] = {}
+
+    # Resolve NamedType references from the workspace
+    named_refs: set[str] = set()
+    for field in version.fields:
+        _collect_named_type_refs(field.type, named_refs)
+    named_type_map, use_statements = _resolve_named_type_map(named_refs, mdl)
+
     field_specs = _field_specs_from_model_fields(
-        version.fields, owner_type=type_name, path=[], definitions=nested_definitions
+        version.fields,
+        owner_type=type_name,
+        path=[],
+        definitions=nested_definitions,
+        enum_info=local_enum_info,
+        named_type_map=named_type_map,
     )
+    if enum_registry is not None:
+        enum_registry[artifact_id] = {
+            "enums": local_enum_info,
+            "module_name": _snake_case(type_name),
+            "domain": domain.name,
+            "kind": "model",
+        }
+
+    warnings: list[str] = []
+    for field in version.fields:
+        if isinstance(field.type, NamedType) and field.type.name not in named_type_map:
+            warnings.append(missing_metadata(f"{domain.name}.{model_name}.{field.name}"))
 
     needs_serde_with = _any_needs_serde_with(field_specs)
     needs_uuid = _any_needs_uuid(field_specs)
     needs_serde_json = _any_needs_serde_json(field_specs)
-    lines = _header_lines(serde_with=needs_serde_with, uuid=needs_uuid, serde_json=needs_serde_json)
+    lines = _header_lines(
+        serde_with=needs_serde_with, uuid=needs_uuid, serde_json=needs_serde_json, extra_uses=use_statements
+    )
     lines.extend(_render_struct_definition(type_name, field_specs))
     lines.extend(_render_nested_definitions(nested_definitions))
 
@@ -109,7 +262,7 @@ def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_d
         path=out_dir / _module_path(domain.name, type_name),
         content=text,
         content_hash=compute_content_hash(text),
-        warnings=[],
+        warnings=warnings,
     )
 
 
@@ -122,10 +275,12 @@ def _emit_projection(
     *,
     sqlx_fromrow: bool = False,
     clickhouse_row: bool = False,
+    enum_registry: dict[str, dict] | None = None,
 ) -> EmittedArtifact:
     artifact_id = _artifact_id(domain.name, projection_name, version.version)
     type_name = _stable_type_name(domain.name, projection_name, version.version)
     nested_definitions: dict[str, list[str]] = {}
+    local_enum_info: dict[str, list[str]] = {}
 
     field_specs: list[_FieldSpec] = []
     warnings: list[str] = []
@@ -136,16 +291,24 @@ def _emit_projection(
             field_specs.append(_FieldSpec(index=index, name=field.name, annotation="String", optional=False))
             continue
         wire = _resolve_merged_projection_wire(field, version, mdl)
-        annotation = _shape_annotation(
-            field_shape,
-            owner_type=type_name,
-            path=[field.name],
-            definitions=nested_definitions,
-            rust_hint=wire.get("rust"),
-            clickhouse_hint=wire.get("clickhouse"),
-        )
+        if clickhouse_row and field_shape.kind == "enum":
+            # clickhouse-rs 0.15 panics on serialize_unit_variant for typed enums;
+            # force String for all ClickHouse-bound enum fields.
+            annotation = "String"
+        else:
+            annotation = _shape_annotation(
+                field_shape,
+                owner_type=type_name,
+                path=[field.name],
+                definitions=nested_definitions,
+                rust_hint=wire.get("rust"),
+                clickhouse_hint=wire.get("clickhouse"),
+                enum_info=local_enum_info,
+            )
         optional = field_shape.optional or field_shape.nullable
         serde_attrs = _serde_attrs_for_field(wire, field_shape, clickhouse=clickhouse_row)
+        if field_shape.optional and not clickhouse_row:
+            serde_attrs = ['#[serde(skip_serializing_if = "Option::is_none")]', *serde_attrs]
         field_specs.append(
             _FieldSpec(index=index, name=field.name, annotation=annotation, optional=optional, serde_attrs=serde_attrs)
         )
@@ -172,7 +335,19 @@ def _emit_projection(
         _render_struct_definition(type_name, field_specs, extra_derives=extra_derives, storage_gated=storage_gated)
     )
     lines.extend(_render_nested_definitions(nested_definitions))
-    lines.extend(_emit_from_impl(type_name, domain.name, version, mdl, storage_gated=storage_gated))
+    lines.extend(
+        _emit_from_impl(
+            type_name, domain.name, version, mdl, storage_gated=storage_gated, clickhouse_row=clickhouse_row
+        )
+    )
+
+    if enum_registry is not None:
+        enum_registry[artifact_id] = {
+            "enums": local_enum_info,
+            "module_name": _snake_case(type_name),
+            "domain": domain.name,
+            "kind": "projection",
+        }
 
     text = "\n".join(lines) + "\n"
     return EmittedArtifact(
@@ -218,6 +393,7 @@ def _emit_from_impl(
     mdl: MdlFile,
     *,
     storage_gated: bool = False,
+    clickhouse_row: bool = False,
 ) -> list[str]:
     """Emit impl From<SourceModel> for Projection.
 
@@ -250,6 +426,16 @@ def _emit_from_impl(
     if storage_gated:
         lines.append('#[cfg(feature = "storage")]')
     lines.append(f"use super::{src_module}::{src_type_name};")
+    if clickhouse_row:
+        for proj_field in version.fields:
+            if not isinstance(proj_field.mapping, DirectMapping):
+                continue
+            field_shape = _resolve_projection_field_shape(proj_field, version, mdl)
+            if field_shape is not None and field_shape.kind == "enum":
+                enum_type = _nested_type_name(src_type_name, [proj_field.mapping.source_field])
+                if storage_gated:
+                    lines.append('#[cfg(feature = "storage")]')
+                lines.append(f"use super::{src_module}::{enum_type};")
     if storage_gated:
         lines.append('#[cfg(feature = "storage")]')
     lines.append(f"impl From<{src_type_name}> for {proj_type_name} {{")
@@ -261,7 +447,15 @@ def _emit_from_impl(
         if isinstance(proj_field.mapping, DirectMapping):
             src_rust_name = _field_name(proj_field.mapping.source_field)
             field_shape = _resolve_projection_field_shape(proj_field, version, mdl)
-            if _projection_field_is_json_passthrough_to_string(proj_field, version, mdl):
+            if clickhouse_row and field_shape is not None and field_shape.kind == "enum":
+                # ClickHouse-bound enum fields are stored as String; generate explicit match.
+                src_enum_type = _nested_type_name(src_type_name, [proj_field.mapping.source_field])
+                lines.append(f"            {rust_name}: match src.{src_rust_name} {{")
+                for raw_v in field_shape.enum_values:
+                    member = _enum_member_name(raw_v)
+                    lines.append(f'                {src_enum_type}::{member} => "{raw_v}".to_string(),')
+                lines.append("            },")
+            elif _projection_field_is_json_passthrough_to_string(proj_field, version, mdl):
                 lines.append(
                     f"            {rust_name}: serde_json::to_string(&src.{src_rust_name}).unwrap_or_default(),"
                 )
@@ -333,6 +527,7 @@ def _header_lines(
     clickhouse: bool = False,
     uuid: bool = False,
     serde_json: bool = False,
+    extra_uses: list[str] | None = None,
 ) -> list[str]:
     lines = [
         "// @generated by Modelable",
@@ -349,6 +544,9 @@ def _header_lines(
         lines.insert(1, "// requires: uuid (https://docs.rs/uuid)")
     if serde_json:
         lines.insert(1, "// requires: serde_json (https://docs.rs/serde_json)")
+    if extra_uses:
+        # Insert use statements just before the trailing empty string
+        lines[-1:-1] = extra_uses
     return lines
 
 
@@ -437,6 +635,8 @@ def _field_specs_from_model_fields(
     owner_type: str,
     path: list[str],
     definitions: dict[str, list[str]],
+    enum_info: dict[str, list[str]] | None = None,
+    named_type_map: dict[str, str] | None = None,
 ) -> list[_FieldSpec]:
     specs: list[_FieldSpec] = []
     for index, field in enumerate(fields):
@@ -448,6 +648,8 @@ def _field_specs_from_model_fields(
             path=[*path, field.name],
             definitions=definitions,
             rust_hint=wire.get("rust"),
+            enum_info=enum_info,
+            named_type_map=named_type_map,
         )
         is_optional = shape.optional or shape.nullable
         serde_attrs = _serde_attrs_for_field(wire, shape)
@@ -462,6 +664,10 @@ def _field_specs_from_model_fields(
                 definitions=definitions,
                 rust_hint=wire.get("rust"),
             )
+        elif shape.optional:
+            # Omittable field: skip during serialization when None.
+            # Nullable-only fields must always be serialized (as null), so no skip attr.
+            serde_attrs = ['#[serde(skip_serializing_if = "Option::is_none")]', *serde_attrs]
         specs.append(
             _FieldSpec(
                 index=index, name=field.name, annotation=annotation, optional=is_optional, serde_attrs=serde_attrs
@@ -476,6 +682,7 @@ def _field_specs_from_object_fields(
     owner_type: str,
     path: list[str],
     definitions: dict[str, list[str]],
+    enum_info: dict[str, list[str]] | None = None,
 ) -> list[_FieldSpec]:
     specs: list[_FieldSpec] = []
     for index, field in enumerate(fields):
@@ -486,6 +693,7 @@ def _field_specs_from_object_fields(
             path=[*path, field.name],
             definitions=definitions,
             rust_hint=wire.get("rust"),
+            enum_info=enum_info,
         )
         default_none = field.optional or field.shape.optional or field.shape.nullable
         serde_attrs = _serde_attrs_for_field(wire, field.shape)
@@ -505,6 +713,8 @@ def _shape_annotation(
     definitions: dict[str, list[str]],
     rust_hint=None,
     clickhouse_hint=None,
+    enum_info: dict[str, list[str]] | None = None,
+    named_type_map: dict[str, str] | None = None,
 ) -> str:
     base = _shape_base_annotation(
         shape,
@@ -513,6 +723,8 @@ def _shape_annotation(
         definitions=definitions,
         rust_hint=rust_hint,
         clickhouse_hint=clickhouse_hint,
+        enum_info=enum_info,
+        named_type_map=named_type_map,
     )
     if shape.optional or shape.nullable:
         return f"Option<{base}>"
@@ -527,6 +739,8 @@ def _shape_base_annotation(
     definitions: dict[str, list[str]],
     rust_hint=None,
     clickhouse_hint=None,
+    enum_info: dict[str, list[str]] | None = None,
+    named_type_map: dict[str, str] | None = None,
 ) -> str:
     clickhouse_string = clickhouse_hint is not None and getattr(clickhouse_hint, "encoding", None) == "string"
     if shape.kind == "primitive":
@@ -545,6 +759,8 @@ def _shape_base_annotation(
             path=[*path, "Item"],
             definitions=definitions,
             rust_hint=rust_hint,
+            enum_info=enum_info,
+            named_type_map=named_type_map,
         )
         return f"Vec<{element_type}>"
     if shape.kind == "map":
@@ -556,6 +772,8 @@ def _shape_base_annotation(
             owner_type=owner_type,
             path=[*path, "Value"],
             definitions=definitions,
+            enum_info=enum_info,
+            named_type_map=named_type_map,
         )
         return f"HashMap<String, {value_type}>"
     if shape.kind == "ref":
@@ -564,8 +782,12 @@ def _shape_base_annotation(
         enum_type_name = _nested_type_name(owner_type, path)
         if enum_type_name not in definitions:
             definitions[enum_type_name] = _render_enum_definition(enum_type_name, list(shape.enum_values))
+        if enum_info is not None and enum_type_name not in enum_info:
+            enum_info[enum_type_name] = list(shape.enum_values)
         return enum_type_name
     if shape.kind == "named":
+        if named_type_map is not None and shape.ref in named_type_map:
+            return named_type_map[shape.ref]
         return _pascalize(shape.ref or "Named")
     if shape.kind == "object":
         type_name = _nested_type_name(owner_type, path)
@@ -577,6 +799,7 @@ def _shape_base_annotation(
                     owner_type=owner_type,
                     path=path,
                     definitions=definitions,
+                    enum_info=enum_info,
                 ),
             )
         return type_name

{modelable-1.0.0 → modelable-1.0.2}/src/modelable/emitters/typescript.py

@@ -92,15 +92,39 @@ def _collect_ref_imports(field_type, mdl, resolved_refs: dict[str, str]) -> None
             _collect_ref_imports(f.type, mdl, resolved_refs)
 
 
+def _collect_named_imports(field_type, mdl, named_imports: dict[str, tuple[str, str]]) -> None:
+    """Recursively resolve NamedType refs to (exported_alias, artifact_id) in named_imports."""
+    if isinstance(field_type, NamedType):
+        name = field_type.name
+        if name not in named_imports and mdl is not None:
+            for domain in mdl.domains:
+                if name in domain.models:
+                    versions = domain.models[name]
+                    if versions:
+                        latest = max(versions, key=lambda v: v.version)
+                        aid = _artifact_id(domain.name, name, latest.version)
+                        named_imports[name] = (name, aid)
+                        return
+    elif isinstance(field_type, ArrayType):
+        _collect_named_imports(field_type.item, mdl, named_imports)
+    elif isinstance(field_type, MapType):
+        _collect_named_imports(field_type.value, mdl, named_imports)
+    elif isinstance(field_type, ObjectType):
+        for f in field_type.fields:
+            _collect_named_imports(f.type, mdl, named_imports)
+
+
 def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_dir: Path, mdl=None) -> EmittedArtifact:
     artifact_id = _artifact_id(domain.name, model_name, version.version)
     interface_name = _stable_interface_name(domain.name, model_name, version.version)
 
     # Resolve ref<X> fields to stable interface names; collect imports.
     resolved_refs: dict[str, str] = {}  # ref target → stable interface name
+    named_imports: dict[str, tuple[str, str]] = {}  # bare name → (stable iface name, artifact_id)
     if mdl is not None:
         for field in version.fields:
             _collect_ref_imports(field.type, mdl, resolved_refs)
+            _collect_named_imports(field.type, mdl, named_imports)
 
     declaration_json_wire = version.wire_targets().get("json")
     field_case = declaration_json_wire.field_case if declaration_json_wire is not None else None
@@ -109,6 +133,9 @@ def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_d
     for iface in sorted(set(resolved_refs.values())):
         iface_id = _iface_to_artifact_id(iface)
         import_lines.append(f'import type {{ {iface} }} from "./{iface_id}";')
+    for name in sorted(named_imports):
+        iface, aid = named_imports[name]
+        import_lines.append(f'import type {{ {iface} }} from "./{aid}";')
 
     meta_lines = _metadata_lines(
         _domain_metadata_entries(
@@ -123,16 +150,16 @@ def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_d
     body_lines.append(f"export interface {interface_name} {{")
     warnings: list[str] = []
     for field in version.fields:
-        if isinstance(field.type, NamedType):
+        if isinstance(field.type, NamedType) and field.type.name not in named_imports:
             warnings.append(missing_metadata(f"{domain.name}.{model_name}.{field.name}"))
         field_name = _apply_case(field.name, field_case) if field_case else field.name
         body_lines.append(
-            f"  {field_name}{'?' if field.optional else ''}: {_type_to_ts(field.type, wire_targets=field.wire_targets(), resolved_refs=resolved_refs)};"
+            f"  {field_name}{'?' if field.optional else ''}: {_type_to_ts(field.type, wire_targets=field.wire_targets(), resolved_refs=resolved_refs, named_imports=named_imports)};"
         )
     body_lines.append("}")
     body_lines.append(f"export type {model_name} = {interface_name};")
 
-    all_lines = import_lines + ([""] if import_lines else []) + meta_lines + body_lines
+    all_lines = meta_lines + ([*import_lines, ""] if import_lines else []) + body_lines
     content = "\n".join(all_lines) + "\n"
     return EmittedArtifact(
         target="typescript",
@@ -286,6 +313,7 @@ def _type_to_ts(
     *,
     wire_targets: dict[str, object] | None = None,
     resolved_refs: dict[str, str] | None = None,
+    named_imports: dict[str, tuple[str, str]] | None = None,
 ) -> str:
     json_wire = None
     if wire_targets is not None:
@@ -314,12 +342,14 @@ def _type_to_ts(
     if isinstance(field_type, DecimalType):
         return "string"
     if isinstance(field_type, ArrayType):
-        item_ts = _type_to_ts(field_type.item)
+        item_ts = _type_to_ts(field_type.item, resolved_refs=resolved_refs, named_imports=named_imports)
         if isinstance(field_type.item, EnumType):
             return f"({item_ts})[]"
         return f"{item_ts}[]"
     if isinstance(field_type, MapType):
-        return f"Record<string, {_type_to_ts(field_type.value)}>"
+        return (
+            f"Record<string, {_type_to_ts(field_type.value, resolved_refs=resolved_refs, named_imports=named_imports)}>"
+        )
     if isinstance(field_type, RefType):
         if resolved_refs and field_type.target in resolved_refs:
             return resolved_refs[field_type.target]
@@ -339,11 +369,13 @@ def _type_to_ts(
         return values or "string"
     if isinstance(field_type, ObjectType):
         inner = "; ".join(
-            f"{field.name}{'?' if field.optional else ''}: {_type_to_ts(field.type, wire_targets=field.wire_targets(), resolved_refs=resolved_refs)}"
+            f"{field.name}{'?' if field.optional else ''}: {_type_to_ts(field.type, wire_targets=field.wire_targets(), resolved_refs=resolved_refs, named_imports=named_imports)}"
             for field in field_type.fields
         )
         return f"{{ {inner} }}"
     if isinstance(field_type, NamedType):
+        if named_imports and field_type.name in named_imports:
+            return named_imports[field_type.name][0]
         return field_type.name
     if field_type is None:
         return "unknown"

{modelable-1.0.0 → modelable-1.0.2}/src/modelable/grammar/modelable.lark

@@ -96,7 +96,11 @@ primitive_type: "string"    -> pt_string
               | "json"      -> pt_json
 
 decimal_type: "decimal" "(" INT "," INT ")"
-enum_type: "enum" "(" IDENT ("," IDENT)* ")"
+enum_type: "enum" "(" enum_member ("," enum_member)* ")"
+enum_member: IDENT
+           | NUMERIC_IDENT
+
+NUMERIC_IDENT: /[0-9][A-Za-z0-9_-]*/
 array_type: "array" "<" type_expr ">"
 map_type: "map" "<" type_expr "," type_expr ">"
 ref_type: "ref" "<" dotted_ref ">"