modelable 1.2.0__tar.gz → 1.2.1__tar.gz

{modelable-1.2.0 → modelable-1.2.1}/PKG-INFO

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

{modelable-1.2.0 → modelable-1.2.1}/mypy-baseline.txt

@@ -133,35 +133,35 @@ src/modelable/emitters/python.py:279: error: Function is missing a type annotati
 src/modelable/emitters/python.py:293: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
 src/modelable/emitters/python.py:293: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
 src/modelable/emitters/python.py:75: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:1001: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
+src/modelable/emitters/rust.py:1001: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
+src/modelable/emitters/rust.py:1005: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:1005: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:1013: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+src/modelable/emitters/rust.py:1018: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+src/modelable/emitters/rust.py:1022: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
 src/modelable/emitters/rust.py:116: error: Missing type arguments for generic type "dict"  [type-arg]
 src/modelable/emitters/rust.py:128: error: Incompatible types in assignment (expression has type "list[ProjectionVersion]", variable has type "list[ModelVersion]")  [assignment]
 src/modelable/emitters/rust.py:130: error: "ModelVersion" has no attribute "source"  [attr-defined]
 src/modelable/emitters/rust.py:135: error: Argument 3 to "_emit_projection" has incompatible type "ModelVersion"; expected "ProjectionVersion"  [arg-type]
 src/modelable/emitters/rust.py:190: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/rust.py:190: error: Missing type arguments for generic type "set"  [type-arg]
-src/modelable/emitters/rust.py:201: error: Missing type arguments for generic type "set"  [type-arg]
-src/modelable/emitters/rust.py:316: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:372: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:381: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:211: error: Missing type arguments for generic type "set"  [type-arg]
+src/modelable/emitters/rust.py:326: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:387: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:396: error: Missing type arguments for generic type "dict"  [type-arg]
 src/modelable/emitters/rust.py:41: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:467: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:495: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/rust.py:56: error: Missing type arguments for generic type "frozenset"  [type-arg]
-src/modelable/emitters/rust.py:578: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:735: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:782: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:811: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:837: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:851: error: Returning Any from function declared to return "str"  [no-any-return]
+src/modelable/emitters/rust.py:609: error: Missing type arguments for generic type "dict"  [type-arg]
+src/modelable/emitters/rust.py:776: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:823: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:852: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:878: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
+src/modelable/emitters/rust.py:892: error: Returning Any from function declared to return "str"  [no-any-return]
 src/modelable/emitters/rust.py:93: error: Item "dict[str, object]" of "dict[str, object] | str" has no attribute "rstrip"  [union-attr]
-src/modelable/emitters/rust.py:946: error: Function is missing a return type annotation  [no-untyped-def]
-src/modelable/emitters/rust.py:946: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:960: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "optional"  [union-attr]
-src/modelable/emitters/rust.py:960: error: Item "ProjectionField" of "FieldDef | ProjectionField" has no attribute "type"  [union-attr]
-src/modelable/emitters/rust.py:964: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
-src/modelable/emitters/rust.py:964: error: Missing type arguments for generic type "dict"  [type-arg]
-src/modelable/emitters/rust.py:972: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
-src/modelable/emitters/rust.py:977: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
-src/modelable/emitters/rust.py:981: error: Returning Any from function declared to return "dict[Any, Any]"  [no-any-return]
+src/modelable/emitters/rust.py:987: error: Function is missing a return type annotation  [no-untyped-def]
+src/modelable/emitters/rust.py:987: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/sql.py:196: error: Function is missing a return type annotation  [no-untyped-def]
 src/modelable/emitters/sql.py:196: error: Function is missing a type annotation for one or more parameters  [no-untyped-def]
 src/modelable/emitters/sql.py:211: error: Function is missing a return type annotation  [no-untyped-def]

{modelable-1.2.0 → modelable-1.2.1}/pyproject.toml

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

{modelable-1.2.0 → modelable-1.2.1}/src/modelable/emitters/rust.py

@@ -198,6 +198,16 @@ def _collect_named_type_refs(field_type, result: set) -> None:
         _collect_named_type_refs(field_type.value, result)
 
 
+def _collect_named_type_refs_from_shape(shape: TypeShape, result: set[str]) -> None:
+    """Recursively collect NamedType references from a resolved TypeShape."""
+    if shape.kind == "named" and shape.ref:
+        result.add(shape.ref)
+    elif shape.kind == "array" and shape.element is not None:
+        _collect_named_type_refs_from_shape(shape.element, result)
+    elif shape.kind == "map" and shape.value is not None:
+        _collect_named_type_refs_from_shape(shape.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.
 
@@ -207,7 +217,7 @@ def _resolve_named_type_map(named_refs: set, mdl: MdlFile | None) -> tuple[dict[
         return {}, []
     resolved_map: dict[str, str] = {}
     use_statements: list[str] = []
-    for name in named_refs:
+    for name in sorted(named_refs):
         resolved = False
         for domain in mdl.domains:
             if name in domain.models:
@@ -351,8 +361,13 @@ def _emit_model(
     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)
+    needs_hashmap = _any_needs_hashmap(field_specs, nested_definitions)
     lines = _header_lines(
-        serde_with=needs_serde_with, uuid=needs_uuid, serde_json=needs_serde_json, extra_uses=use_statements
+        serde_with=needs_serde_with,
+        uuid=needs_uuid,
+        serde_json=needs_serde_json,
+        hashmap=needs_hashmap,
+        extra_uses=use_statements,
     )
     lines.extend(_render_struct_definition(type_name, field_specs))
     lines.extend(_render_nested_definitions(nested_definitions))
@@ -385,10 +400,19 @@ def _emit_projection(
     nested_definitions: dict[str, list[str]] = {}
     local_enum_info: dict[str, list[str]] = {}
 
+    field_shapes: dict[str, TypeShape | None] = {
+        field.name: _resolve_projection_field_shape(field, version, mdl) for field in version.fields
+    }
+    named_refs: set[str] = set()
+    for field_shape in field_shapes.values():
+        if field_shape is not None:
+            _collect_named_type_refs_from_shape(field_shape, named_refs)
+    named_type_map, use_statements = _resolve_named_type_map(named_refs, mdl)
+
     field_specs: list[_FieldSpec] = []
     warnings: list[str] = []
     for index, field in enumerate(version.fields):
-        field_shape = _resolve_projection_field_shape(field, version, mdl)
+        field_shape = field_shapes[field.name]
         if field_shape is None:
             warnings.append(type_loss(f"{domain.name}.{projection_name}.{field.name}"))
             field_specs.append(_FieldSpec(index=index, name=field.name, annotation="String", optional=False))
@@ -407,6 +431,7 @@ def _emit_projection(
                 rust_hint=wire.get("rust"),
                 clickhouse_hint=wire.get("clickhouse"),
                 enum_info=local_enum_info,
+                named_type_map=named_type_map,
             )
         optional = field_shape.optional or field_shape.nullable
         serde_attrs = _serde_attrs_for_field(wire, field_shape, clickhouse=clickhouse_row)
@@ -421,6 +446,7 @@ def _emit_projection(
     needs_serde_json = _any_needs_serde_json(field_specs) or any(
         _projection_field_is_json_passthrough_to_string(f, version, mdl) for f in version.fields
     )
+    needs_hashmap = _any_needs_hashmap(field_specs, nested_definitions)
     storage_gated = sqlx_fromrow or clickhouse_row
     extra_derives: list[str] = []
     if sqlx_fromrow:
@@ -433,6 +459,8 @@ def _emit_projection(
         clickhouse=clickhouse_row,
         uuid=needs_uuid,
         serde_json=needs_serde_json,
+        hashmap=needs_hashmap,
+        extra_uses=use_statements,
     )
     lines.extend(
         _render_struct_definition(type_name, field_specs, extra_derives=extra_derives, storage_gated=storage_gated)
@@ -541,6 +569,9 @@ def _emit_from_impl(
                 lines.append(f"use super::{src_module}::{enum_type};")
     if storage_gated:
         lines.append('#[cfg(feature = "storage")]')
+    # Direct-mapped fields always go through `.into()` below, which is a no-op
+    # (and a clippy lint) when the source and projected field share a type.
+    lines.append("#[allow(clippy::useless_conversion)]")
     lines.append(f"impl From<{src_type_name}> for {proj_type_name} {{")
     lines.append(f"    fn from(src: {src_type_name}) -> Self {{")
     lines.append("        Self {")
@@ -608,6 +639,16 @@ def _any_needs_serde_json(field_specs: list[_FieldSpec]) -> bool:
     return any("serde_json::Value" in spec.annotation for spec in field_specs)
 
 
+def _any_needs_hashmap(field_specs: list[_FieldSpec], nested_definitions: dict[str, list[str]] | None = None) -> bool:
+    if any("HashMap<" in spec.annotation for spec in field_specs):
+        return True
+    if nested_definitions:
+        for lines in nested_definitions.values():
+            if any("HashMap<" in line for line in lines):
+                return True
+    return False
+
+
 def _shape_involves_object(shape: TypeShape) -> bool:
     """Return True if the shape contains an inline object type.
 
@@ -630,13 +671,13 @@ def _header_lines(
     clickhouse: bool = False,
     uuid: bool = False,
     serde_json: bool = False,
+    hashmap: bool = False,
     extra_uses: list[str] | None = None,
 ) -> list[str]:
-    lines = [
-        "// @generated by Modelable",
-        "use std::collections::HashMap;",
-        "",
-    ]
+    lines = ["// @generated by Modelable"]
+    if hashmap:
+        lines.append("use std::collections::HashMap;")
+    lines.append("")
     if clickhouse:
         lines.insert(1, "// requires: clickhouse (https://docs.rs/clickhouse)")
     if sqlx:

{modelable-1.2.0 → modelable-1.2.1}/tests/test_emit_rust.py

@@ -1,4 +1,7 @@
 import hashlib
+import os
+import subprocess
+import sys
 
 from click.testing import CliRunner
 
@@ -388,6 +391,168 @@ domain customer {
     assert "pub name: String," in proj_art.content
 
 
+def test_emit_rust_projection_imports_named_type_fields(tmp_path):
+    mdl = tmp_path / "test.mdl"
+    mdl.write_text(
+        """
+domain orders {
+  owner: "test-team"
+
+  semantic BuyerId : uuid(7)
+
+  value OrderLine @ 1 (additive) {
+    sku: string
+    quantity: u32
+  }
+
+  event OrderPlaced @ 1 (additive) {
+    orderId: uuid
+    buyerId: BuyerId
+    lines: array<OrderLine>
+  }
+
+  projection OrderHistory @ 1
+    from orders.OrderPlaced @ 1 as placed
+  {
+    orderId <- placed.orderId
+    buyerId <- placed.buyerId
+    lines <- placed.lines
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    from modelable.compiler.workspace import load_workspace
+
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    proj_art = next(a for a in artifacts if a.ref == "orders.OrderHistory@1")
+    # Field types must be the generated Rust type names, not the raw .mdl names.
+    assert "pub buyer_id: BuyerId," in proj_art.content
+    assert "pub lines: Vec<OrdersOrderLineV1>," in proj_art.content
+    # Every named type referenced by a field must have a matching use import.
+    assert "use super::buyer_id::BuyerId;" in proj_art.content
+    assert "use super::orders_order_line_v1::OrdersOrderLineV1;" in proj_art.content
+
+
+def test_emit_rust_named_type_use_statements_are_hash_seed_independent(tmp_path):
+    """Rust output must be byte-identical across processes/interpreters.
+
+    `use` statements for named-type fields are built by iterating a `set` of
+    reference names. CPython's set iteration order for strings depends on
+    PYTHONHASHSEED, so an unsorted iteration reorders the generated `use`
+    lines between runs unless the seed is pinned — breaking reproducible
+    builds. Run the emitter in two subprocesses with different hash seeds
+    and require identical output.
+    """
+    mdl = tmp_path / "test.mdl"
+    mdl.write_text(
+        """
+domain orders {
+  owner: "test-team"
+
+  semantic BuyerId : uuid(7)
+  semantic CartId : uuid(7)
+  semantic OrderId : uuid(7)
+
+  value OrderLine @ 1 (additive) {
+    sku: string
+  }
+
+  entity Order @ 1 (additive) {
+    @key orderId: OrderId
+    cartId: CartId
+    buyerId: BuyerId
+    lines: array<OrderLine>
+  }
+
+  event OrderPlaced @ 1 (additive) {
+    orderId: OrderId
+    cartId: CartId
+    buyerId: BuyerId
+    lines: array<OrderLine>
+  }
+
+  projection OrderHistory @ 1
+    from orders.OrderPlaced @ 1 as placed
+  {
+    orderId <- placed.orderId
+    cartId <- placed.cartId
+    buyerId <- placed.buyerId
+    lines <- placed.lines
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    script = tmp_path / "emit.py"
+    script.write_text(
+        "import sys\n"
+        "from pathlib import Path\n"
+        "from modelable.compiler.workspace import load_workspace\n"
+        "from modelable.emitters.rust import emit_rust\n"
+        "workspace = load_workspace(Path(sys.argv[1]))\n"
+        "artifacts = emit_rust(workspace, Path(sys.argv[1]) / 'out')\n"
+        "for artifact in sorted(artifacts, key=lambda a: a.ref):\n"
+        "    print(artifact.ref)\n"
+        "    print(artifact.content)\n",
+        encoding="utf-8",
+    )
+
+    def run_with_seed(seed: str) -> str:
+        env = {**os.environ, "PYTHONHASHSEED": seed}
+        result = subprocess.run(
+            [sys.executable, str(script), str(tmp_path)],
+            capture_output=True,
+            text=True,
+            env=env,
+            check=True,
+        )
+        return result.stdout
+
+    output_seed_0 = run_with_seed("0")
+    output_seed_1 = run_with_seed("1")
+    assert output_seed_0 == output_seed_1
+
+
+def test_emit_rust_omits_hashmap_import_when_unused(tmp_path):
+    mdl = tmp_path / "test.mdl"
+    mdl.write_text(
+        """
+domain orders {
+  owner: "test-team"
+  value OrderLine @ 1 (additive) {
+    sku: string
+    quantity: u32
+  }
+
+  entity Order @ 1 (additive) {
+    @key orderId: uuid
+    lines: array<OrderLine>
+  }
+
+  projection OrderView @ 1
+    from orders.Order @ 1 as o
+  {
+    orderId <- o.orderId
+    lines <- o.lines
+  }
+}
+""",
+        encoding="utf-8",
+    )
+    workspace = load_workspace(tmp_path)
+    artifacts = emit_rust(workspace, tmp_path / "out")
+    # Neither struct has a map field, so the HashMap import (and the unused
+    # import it would otherwise produce) must not appear.
+    line_art = next(a for a in artifacts if a.ref == "orders.OrderLine@1")
+    order_art = next(a for a in artifacts if a.ref == "orders.Order@1")
+    view_art = next(a for a in artifacts if a.ref == "orders.OrderView@1")
+    assert "use std::collections::HashMap;" not in line_art.content
+    assert "use std::collections::HashMap;" not in order_art.content
+    assert "use std::collections::HashMap;" not in view_art.content
+
+
 def test_emit_rust_struct_has_serde_derives(tmp_path):
     mdl = tmp_path / "test.mdl"
     mdl.write_text(
@@ -769,6 +934,9 @@ domain customer {
     assert "customer_id: src.customer_id.into()," in proj.content
     assert "display_name: src.display_name.into()," in proj.content
     assert "use super::customer_customer_v1::CustomerCustomerV1;" in proj.content
+    # Direct-mapped fields keep an unconditional `.into()`, which is a no-op
+    # when source and target share a type; silence the resulting clippy lint.
+    assert "#[allow(clippy::useless_conversion)]\nimpl From<CustomerCustomerV1>" in proj.content
     # Model struct itself should NOT have a From impl (no projection source)
     model = next(a for a in artifacts if a.ref == "customer.Customer@1")
     assert "impl From<" not in model.content

{modelable-1.2.0 → modelable-1.2.1}/uv.lock

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