modelable 1.0.1__tar.gz → 1.0.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelable
-Version: 1.0.1
+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.1 → modelable-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modelable"
-version = "1.0.1"
+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.1 → modelable-1.0.2}/src/modelable/emitters/rust.py

@@ -9,7 +9,16 @@ from modelable.compiler.workspace import Workspace
 from modelable.emitters.base import EmittedArtifact, compute_content_hash
 from modelable.emitters.diagnostics import missing_metadata, type_loss
 from modelable.emitters.shapes import TypeShape
-from modelable.parser.ir import DirectMapping, DomainDef, MdlFile, ModelVersion, NamedType, ProjectionVersion
+from modelable.parser.ir import (
+    ArrayType,
+    DirectMapping,
+    DomainDef,
+    MapType,
+    MdlFile,
+    ModelVersion,
+    NamedType,
+    ProjectionVersion,
+)
 from modelable.registry.resolver import resolve_model_ref
 
 
@@ -27,33 +36,35 @@ def _append_cross_enum_from_impls(
     enum_registry: dict[str, dict],
 ) -> list[EmittedArtifact]:
     """For each pair of enum types with identical variants in the same domain,
-    append From impl blocks so the types convert into each other without manual match arms.
+    append From impl blocks into projection files without manual match arms.
     """
-    # Group by domain: domain -> [(artifact_id, module_name, enums_dict)]
-    by_domain: dict[str, list[tuple[str, str, dict[str, list[str]]]]] = {}
+    # 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"]))
+        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]]] = {}
-        for art_id, module_name, enums in entries:
+        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))
+                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 in enum_list:
-                for tgt_art_id, _tgt_module, tgt_enum in enum_list:
+            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};",
@@ -100,7 +111,9 @@ def emit_rust(workspace: Workspace, out_dir: Path) -> 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, enum_registry=enum_registry))
+                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
@@ -157,6 +170,40 @@ def _stable_type_name(domain: str, name: str, version: int) -> str:
     return f"{_pascalize(domain)}{_pascalize(name)}V{version}"
 
 
+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,
@@ -164,30 +211,46 @@ def _emit_model(
     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, enum_info=local_enum_info
+        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):
+        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))
 
@@ -228,18 +291,23 @@ 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"),
-            enum_info=local_enum_info,
-        )
+        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:
+        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)
@@ -267,13 +335,18 @@ 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"
@@ -320,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.
 
@@ -352,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} {{")
@@ -363,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(),"
                 )
@@ -435,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",
@@ -451,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
 
 
@@ -540,6 +636,7 @@ def _field_specs_from_model_fields(
     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):
@@ -552,6 +649,7 @@ def _field_specs_from_model_fields(
             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)
@@ -616,6 +714,7 @@ def _shape_annotation(
     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,
@@ -625,6 +724,7 @@ def _shape_annotation(
         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}>"
@@ -640,6 +740,7 @@ def _shape_base_annotation(
     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":
@@ -659,6 +760,7 @@ def _shape_base_annotation(
             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":
@@ -671,6 +773,7 @@ def _shape_base_annotation(
             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":
@@ -683,6 +786,8 @@ def _shape_base_annotation(
             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)

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

@@ -93,7 +93,7 @@ def _collect_ref_imports(field_type, mdl, resolved_refs: dict[str, str]) -> None
 
 
 def _collect_named_imports(field_type, mdl, named_imports: dict[str, tuple[str, str]]) -> None:
-    """Recursively resolve NamedType refs to (stable_iface_name, artifact_id) in named_imports."""
+    """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:
@@ -102,9 +102,8 @@ def _collect_named_imports(field_type, mdl, named_imports: dict[str, tuple[str,
                     versions = domain.models[name]
                     if versions:
                         latest = max(versions, key=lambda v: v.version)
-                        iface = _stable_interface_name(domain.name, name, latest.version)
                         aid = _artifact_id(domain.name, name, latest.version)
-                        named_imports[name] = (iface, aid)
+                        named_imports[name] = (name, aid)
                         return
     elif isinstance(field_type, ArrayType):
         _collect_named_imports(field_type.item, mdl, named_imports)
@@ -160,7 +159,7 @@ def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_d
     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",

{modelable-1.0.1 → modelable-1.0.2}/tests/test_emit_rust.py

@@ -461,6 +461,55 @@ binding span-row-binding {
     assert '#[cfg(feature = "storage")]' not in model.content
 
 
+def test_emit_rust_clickhouse_row_omits_skip_serializing_if_on_optional_fields(tmp_path):
+    """Nullable ClickHouse row columns must serialize as NULL, not disappear."""
+    (tmp_path / "model.mdl").write_text(
+        """
+domain telemetry {
+  owner: "test-team"
+  entity Log @ 1 (additive) {
+    @key logId: uuid
+    traceId?: string
+    message: string
+  }
+
+  projection LogRow @ 1
+    from telemetry.Log @ 1 as l
+  {
+    logId <- l.logId
+    traceId <- l.traceId
+    message <- l.message
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    (tmp_path / "bindings.mdl").write_text(
+        """
+binding ch-conn {
+  adapter: clickhouse
+}
+
+binding log-row-binding {
+  model: telemetry.Log @ 1
+  adapter: ch-conn
+  table: "logs"
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+
+    row = next(a for a in artifacts if a.ref == "telemetry.LogRow@1")
+    assert "clickhouse::Row" in row.content
+    assert "pub trace_id: Option<String>," in row.content
+    assert '#[serde(skip_serializing_if = "Option::is_none")]' not in row.content
+
+    model = next(a for a in artifacts if a.ref == "telemetry.Log@1")
+    assert '#[serde(skip_serializing_if = "Option::is_none")]' in model.content
+
+
 def test_emit_rust_clickhouse_row_indirect_connector_binding(tmp_path):
     """Model binding via connector-binding name → adapter type resolved correctly for clickhouse."""
     (tmp_path / "all.mdl").write_text(
@@ -1002,17 +1051,14 @@ domain catalog {
 
 
 def test_emit_rust_warns_on_named_type_field(tmp_path):
-    """Rust emitter emits EMIT003 for NamedType field references (issue #120)."""
+    """Rust emitter emits EMIT003 for NamedType field references to unknown external types (issue #120)."""
     (tmp_path / "test.mdl").write_text(
         """
 domain customer {
   owner: "test-team"
-  value Address {
-    line1: string
-  }
   entity Customer @ 1 (additive) {
     @key customerId: uuid
-    address: Address
+    address: ExternalAddress
   }
 }
 """,
@@ -1084,6 +1130,156 @@ domain tracing {
     assert "impl From<TracingSpanV1SpanKind> for TracingSpanRowV1SpanKind" in proj_art.content
     assert "use super::tracing_span_v1::TracingSpanV1SpanKind;" in proj_art.content
 
-    # Model file gets From<ProjEnum> for ModelEnum
-    assert "impl From<TracingSpanRowV1SpanKind> for TracingSpanV1SpanKind" in model_art.content
-    assert "use super::tracing_span_row_v1::TracingSpanRowV1SpanKind;" in model_art.content
+    # Domain model files must not import projection/storage enum types.
+    assert "TracingSpanRowV1SpanKind" not in model_art.content
+    assert "use super::tracing_span_row_v1" not in model_art.content
+
+
+def test_emit_rust_named_type_in_same_domain_resolves_without_warning(tmp_path):
+    """NamedType references to models in the same workspace resolve without EMIT003 (issue #120)."""
+    (tmp_path / "test.mdl").write_text(
+        """
+domain nlq {
+  owner: "test-team"
+  value NlqTimeRange {
+    from: string
+    to: string
+  }
+  value NlqIr {
+    timeRange: NlqTimeRange
+    query: string
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    ir_art = next(a for a in artifacts if a.ref == "nlq.NlqIr@0")
+    # The field must use the stable Rust type name (value types without @ N default to version 0)
+    assert "pub time_range: NlqNlqTimeRangeV0," in ir_art.content
+    # A use statement must be emitted
+    assert "use super::nlq_nlq_time_range_v0::NlqNlqTimeRangeV0;" in ir_art.content
+    # No EMIT003 warning
+    assert not any("EMIT003" in w for w in ir_art.warnings)
+
+
+def test_emit_rust_named_type_array_in_same_domain_resolves(tmp_path):
+    """NamedType inside array<...> resolves to Vec<StableTypeName> (issue #120)."""
+    (tmp_path / "test.mdl").write_text(
+        """
+domain nlq {
+  owner: "test-team"
+  value NlqFilter {
+    field: string
+    value: string
+  }
+  value NlqQuery {
+    filters: array<NlqFilter>
+    query: string
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    query_art = next(a for a in artifacts if a.ref == "nlq.NlqQuery@0")
+    assert "pub filters: Vec<NlqNlqFilterV0>," in query_art.content
+    assert "use super::nlq_nlq_filter_v0::NlqNlqFilterV0;" in query_art.content
+    assert not any("EMIT003" in w for w in query_art.warnings)
+
+
+def test_emit_rust_clickhouse_row_enum_field_uses_string(tmp_path):
+    """ClickHouse-bound projection enum fields must be String, not typed enum (issue #119)."""
+    (tmp_path / "model.mdl").write_text(
+        """
+domain telemetry {
+  owner: "test-team"
+  entity Span @ 1 (additive) {
+    @key spanId: uuid
+    spanKind: enum(INTERNAL, SERVER, CLIENT)
+    name: string
+  }
+
+  projection SpanRow @ 1
+    from telemetry.Span @ 1 as s
+  {
+    spanId <- s.spanId
+    spanKind <- s.spanKind
+    name <- s.name
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    (tmp_path / "bindings.mdl").write_text(
+        """
+binding ch-conn {
+  adapter: clickhouse
+}
+
+binding span-binding {
+  model: telemetry.Span @ 1
+  adapter: ch-conn
+  table: "spans"
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    proj = next(a for a in artifacts if a.ref == "telemetry.SpanRow@1")
+    # Enum field must be String in the ClickHouse projection
+    assert "pub span_kind: String," in proj.content
+    # No typed enum definition for the projection
+    assert "pub enum TelemetrySpanRowV1SpanKind" not in proj.content
+    # Ensure typed enum is not used as field type
+    assert "pub span_kind: TelemetrySpanV1SpanKind," not in proj.content
+
+
+def test_emit_rust_clickhouse_row_from_impl_enum_becomes_match_arm(tmp_path):
+    """From impl for ClickHouse row with enum fields uses explicit match → String (issue #119)."""
+    (tmp_path / "model.mdl").write_text(
+        """
+domain telemetry {
+  owner: "test-team"
+  entity Span @ 1 (additive) {
+    @key spanId: uuid
+    spanKind: enum(INTERNAL, SERVER, CLIENT)
+    name: string
+  }
+
+  projection SpanRow @ 1
+    from telemetry.Span @ 1 as s
+  {
+    spanId <- s.spanId
+    spanKind <- s.spanKind
+    name <- s.name
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    (tmp_path / "bindings.mdl").write_text(
+        """
+binding ch-conn {
+  adapter: clickhouse
+}
+
+binding span-binding {
+  model: telemetry.Span @ 1
+  adapter: ch-conn
+  table: "spans"
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    proj = next(a for a in artifacts if a.ref == "telemetry.SpanRow@1")
+    # Match arm generated for enum → String conversion
+    assert "span_kind: match src.span_kind {" in proj.content
+    assert 'TelemetrySpanV1SpanKind::INTERNAL => "INTERNAL".to_string(),' in proj.content
+    # Must NOT use .into() for the enum field
+    assert "span_kind: src.span_kind.into()," not in proj.content

{modelable-1.0.1 → modelable-1.0.2}/tests/test_emit_typescript.py

@@ -677,15 +677,46 @@ domain nlq {
     artifacts = emit_typescript(workspace, tmp_path / "out")
     ir_art = next(a for a in artifacts if "NlqIr" in a.ref)
 
-    # Resolved named type uses stable interface name, not bare name
-    assert "NlqNlqTimeRangeV" in ir_art.content
-    # An import type statement is emitted
-    assert "import type {" in ir_art.content
-    assert "NlqNlqTimeRange" in ir_art.content
+    # Resolved named type uses the exported short alias as the canonical name.
+    assert "timeRange: NlqTimeRange;" in ir_art.content
+    assert 'import type { NlqTimeRange } from "./nlq.NlqTimeRange.v0";' in ir_art.content
+    assert "NlqNlqTimeRangeV" not in ir_art.content
     # EMIT003 must NOT be emitted when the type is successfully resolved
     assert not any("EMIT003" in w for w in ir_art.warnings)
 
 
+def test_emit_typescript_named_type_imports_after_docblock_and_uses_alias(tmp_path):
+    """NamedType imports use the exported short alias after the metadata docblock."""
+    (tmp_path / "test.mdl").write_text(
+        """
+domain nlq {
+  owner: "test-team"
+  value NlqFilter {
+    field: string
+    value: string
+  }
+  value NlqIr {
+    filters: array<NlqFilter>
+    query: string
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_typescript(workspace, tmp_path / "out")
+    ir_art = next(a for a in artifacts if "NlqIr" in a.ref)
+    lines = ir_art.content.splitlines()
+
+    docblock_end = lines.index(" */")
+    import_index = lines.index('import type { NlqFilter } from "./nlq.NlqFilter.v0";')
+    interface_index = lines.index("export interface NlqNlqIrV0 {")
+
+    assert docblock_end < import_index < interface_index
+    assert "filters: NlqFilter[];" in ir_art.content
+    assert "NlqNlqFilterV" not in ir_art.content
+
+
 def test_emit_typescript_named_type_unresolvable_still_warns(tmp_path):
     """NamedType not found in workspace still emits EMIT003 (issue #118)."""
     (tmp_path / "test.mdl").write_text(

{modelable-1.0.1 → modelable-1.0.2}/uv.lock

@@ -348,7 +348,7 @@ wheels = [
 
 [[package]]
 name = "modelable"
-version = "1.0.1"
+version = "1.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },