modelable 1.0.0__py3-none-any.whl

modelable/emitters/fhir_validator.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from collections.abc import Callable
+from pathlib import Path
+
+from modelable.emitters.fhir import FHIR_R4_VERSION
+
+RunCallable = Callable[..., subprocess.CompletedProcess[str]]
+
+
+def validate_fhir_profile(
+    profile: Path,
+    validator_jar: Path,
+    *,
+    java: str = "java",
+    fhir_version: str = FHIR_R4_VERSION,
+    run: RunCallable = subprocess.run,
+) -> subprocess.CompletedProcess[str]:
+    command = [
+        java,
+        "-jar",
+        str(validator_jar),
+        str(profile),
+        "-version",
+        fhir_version,
+    ]
+    return run(
+        command,
+        check=False,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+    )

modelable/emitters/go.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import re
+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.shapes import TypeShape
+from modelable.parser.ir import DirectMapping, DomainDef, ModelVersion, ProjectionVersion
+from modelable.registry.resolver import resolve_model_ref
+
+
+def emit_go(workspace: Workspace, out_dir: Path) -> list[EmittedArtifact]:
+    """Emit Go source files for every model and projection version."""
+    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))
+        for projection_name, versions in domain.projections.items():
+            for version in versions:
+                artifacts.append(_emit_projection(domain, projection_name, version, out_dir, workspace.mdl))
+    return artifacts
+
+
+def _artifact_id(domain: str, name: str, version: int) -> str:
+    return f"{domain}.{name}.v{version}"
+
+
+def _pascalize(value: str) -> str:
+    parts = [part for part in re.split(r"[^A-Za-z0-9]+", value) if part]
+    return "".join(part[:1].upper() + part[1:] for part in parts) or "Generated"
+
+
+def _snake_case(value: str) -> str:
+    text = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", value)
+    text = re.sub(r"[^A-Za-z0-9]+", "_", text)
+    text = text.strip("_").lower()
+    return text or "generated"
+
+
+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:
+    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]] = {}
+    imports: set[str] = set()
+    field_specs = _field_specs_from_model_fields(
+        version.fields,
+        owner_type=type_name,
+        path=[],
+        definitions=nested_definitions,
+        imports=imports,
+    )
+
+    lines = _header_lines(_package_name(domain.name), imports)
+    lines.extend(_render_struct_definition(type_name, field_specs))
+    lines.extend(_render_nested_definitions(nested_definitions))
+
+    text = "\n".join(lines) + "\n"
+    return EmittedArtifact(
+        target="go",
+        ref=f"{domain.name}.{model_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / _module_path(domain.name, type_name),
+        content=text,
+        content_hash=compute_content_hash(text),
+        warnings=[],
+    )
+
+
+def _emit_projection(
+    domain: DomainDef,
+    projection_name: str,
+    version: ProjectionVersion,
+    out_dir: Path,
+    mdl,
+) -> 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]] = {}
+    imports: set[str] = set()
+
+    field_specs: list[tuple[int, str, str, bool]] = []
+    warnings: list[str] = []
+    for index, field in enumerate(version.fields):
+        field_shape = _resolve_projection_field_shape(field, version, mdl)
+        if field_shape is None:
+            warnings.append(type_loss(f"{domain.name}.{projection_name}.{field.name}"))
+            field_specs.append((index, field.name, "any", False))
+            continue
+        annotation = _shape_annotation(
+            field_shape,
+            owner_type=type_name,
+            path=[field.name],
+            definitions=nested_definitions,
+            imports=imports,
+        )
+        optional = field_shape.optional or field_shape.nullable
+        field_specs.append((index, field.name, annotation, optional))
+
+    lines = _header_lines(_package_name(domain.name), imports)
+    lines.extend(_render_struct_definition(type_name, field_specs))
+    lines.extend(_render_nested_definitions(nested_definitions))
+
+    text = "\n".join(lines) + "\n"
+    return EmittedArtifact(
+        target="go",
+        ref=f"{domain.name}.{projection_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / _module_path(domain.name, type_name),
+        content=text,
+        content_hash=compute_content_hash(text),
+        warnings=warnings,
+    )
+
+
+def _header_lines(package_name: str, imports: set[str]) -> list[str]:
+    lines = [
+        "// Code generated by Modelable; DO NOT EDIT.",
+        f"package {package_name}",
+    ]
+    if imports:
+        lines.append("")
+        lines.append("import (")
+        for item in sorted(imports):
+            lines.append(f'    "{item}"')
+        lines.append(")")
+    lines.append("")
+    return lines
+
+
+def _render_nested_definitions(definitions: dict[str, list[str]]) -> list[str]:
+    lines: list[str] = []
+    for definition in definitions.values():
+        lines.append("")
+        lines.extend(definition)
+    return lines
+
+
+def _module_path(domain: str, type_name: str) -> Path:
+    return Path(_package_name(domain)) / _module_filename(type_name)
+
+
+def _package_name(domain: str) -> str:
+    parts = [part.lower() for part in re.split(r"[^A-Za-z0-9]+", domain) if part]
+    return "_".join(parts) or "modelable"
+
+
+def _module_filename(type_name: str) -> str:
+    return f"{_snake_case(type_name)}.go"
+
+
+def _render_struct_definition(type_name: str, field_specs: list[tuple[int, str, str, bool]]) -> list[str]:
+    lines = [f"type {type_name} struct {{"]
+    if not field_specs:
+        lines.append("}")
+        return lines
+    for _, name, annotation, default_none in sorted(field_specs, key=lambda item: (item[3], item[0])):
+        field_name = _field_name(name)
+        tag = _json_tag(name, default_none)
+        lines.append(f"    {field_name} {annotation} {tag}")
+    lines.append("}")
+    return lines
+
+
+def _field_name(value: str) -> str:
+    parts = [part for part in re.split(r"[^A-Za-z0-9]+", value) if part]
+    return "".join(part[:1].upper() + part[1:] for part in parts) or "Field"
+
+
+def _json_tag(value: str, optional: bool) -> str:
+    suffix = ",omitempty" if optional else ""
+    return f'`json:"{value}{suffix}"`'
+
+
+def _field_specs_from_model_fields(
+    fields,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+    imports: set[str],
+) -> list[tuple[int, str, str, bool]]:
+    specs: list[tuple[int, str, str, bool]] = []
+    for index, field in enumerate(fields):
+        shape = TypeShape.from_field_type(field.type, optional=field.optional)
+        annotation = _shape_annotation(
+            shape,
+            owner_type=owner_type,
+            path=[*path, field.name],
+            definitions=definitions,
+            imports=imports,
+        )
+        default_none = shape.optional or shape.nullable
+        specs.append((index, field.name, annotation, default_none))
+    return specs
+
+
+def _field_specs_from_object_fields(
+    fields,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+    imports: set[str],
+) -> list[tuple[int, str, str, bool]]:
+    specs: list[tuple[int, str, str, bool]] = []
+    for index, field in enumerate(fields):
+        annotation = _shape_annotation(
+            field.shape,
+            owner_type=owner_type,
+            path=[*path, field.name],
+            definitions=definitions,
+            imports=imports,
+        )
+        default_none = field.optional or field.shape.optional or field.shape.nullable
+        specs.append((index, field.name, annotation, default_none))
+    return specs
+
+
+def _shape_annotation(
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+    imports: set[str],
+) -> str:
+    base = _shape_base_annotation(shape, owner_type=owner_type, path=path, definitions=definitions, imports=imports)
+    if shape.optional or shape.nullable:
+        return f"*{base}"
+    return base
+
+
+def _shape_base_annotation(
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+    imports: set[str],
+) -> str:
+    if shape.kind == "primitive":
+        return _primitive_to_go(shape.ref or "string", imports=imports)
+    if shape.kind == "decimal":
+        return "string"
+    if shape.kind == "array":
+        element = shape.element or TypeShape(kind="primitive", ref="object")
+        element_type = _shape_annotation(
+            element,
+            owner_type=owner_type,
+            path=[*path, "Item"],
+            definitions=definitions,
+            imports=imports,
+        )
+        return f"[]{element_type}"
+    if shape.kind == "map":
+        value = shape.value or TypeShape(kind="primitive", ref="object")
+        value_type = _shape_annotation(
+            value,
+            owner_type=owner_type,
+            path=[*path, "Value"],
+            definitions=definitions,
+            imports=imports,
+        )
+        return f"map[string]{value_type}"
+    if shape.kind == "ref":
+        return "string"
+    if shape.kind == "enum":
+        return "string"
+    if shape.kind == "named":
+        return _pascalize(shape.ref or "Named")
+    if shape.kind == "object":
+        type_name = _nested_type_name(owner_type, path)
+        if type_name not in definitions:
+            definitions[type_name] = _render_struct_definition(
+                type_name,
+                _field_specs_from_object_fields(
+                    shape.fields,
+                    owner_type=owner_type,
+                    path=path,
+                    definitions=definitions,
+                    imports=imports,
+                ),
+            )
+        return type_name
+    return "any"
+
+
+def _primitive_to_go(kind: str, *, imports: set[str]) -> str:
+    mapping = {
+        "string": "string",
+        "bool": "bool",
+        "int": "int64",
+        "float": "float64",
+        "uuid": "string",
+        "timestamp": "time.Time",
+        "date": "time.Time",
+        "time": "time.Time",
+        "duration": "time.Duration",
+        "binary": "[]byte",
+    }
+    result = mapping.get(kind, "string")
+    if result.startswith("time."):
+        imports.add("time")
+    return result
+
+
+def _nested_type_name(owner_type: str, path: list[str]) -> str:
+    suffix = "".join(_pascalize(part) for part in path)
+    return f"{owner_type}{suffix}" if suffix else owner_type
+
+
+def _resolve_projection_field_shape(field, projection: ProjectionVersion, mdl):
+    if not isinstance(field.mapping, DirectMapping):
+        return None
+    try:
+        source_domain, source_model = projection.source.model.rsplit(".", 1)
+    except ValueError:
+        return None
+    try:
+        resolved = resolve_model_ref(mdl, f"{source_domain}.{source_model}", projection.source.version)
+    except LookupError:
+        return None
+    source_mv = resolved.version
+    for src_field in source_mv.fields:
+        if src_field.name == field.mapping.source_field:
+            return TypeShape.from_field_type(src_field.type, optional=src_field.optional)
+    return None

modelable/emitters/java.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import re
+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.shapes import TypeShape
+from modelable.parser.ir import DirectMapping, DomainDef, ModelVersion, ProjectionVersion
+from modelable.registry.resolver import resolve_model_ref
+
+
+def emit_java(workspace: Workspace, out_dir: Path) -> list[EmittedArtifact]:
+    """Emit Java source files for every model and projection version."""
+    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))
+        for projection_name, versions in domain.projections.items():
+            for version in versions:
+                artifacts.append(_emit_projection(domain, projection_name, version, out_dir, workspace.mdl))
+    return artifacts
+
+
+def _artifact_id(domain: str, name: str, version: int) -> str:
+    return f"{domain}.{name}.v{version}"
+
+
+def _package_name(domain: str) -> str:
+    parts = [part.lower() for part in re.split(r"[^A-Za-z0-9]+", domain) if part]
+    return ".".join(parts) or "modelable"
+
+
+def _pascalize(value: str) -> str:
+    parts = [part for part in re.split(r"[^A-Za-z0-9]+", value) if part]
+    return "".join(part[:1].upper() + part[1:] for part in parts) or "Generated"
+
+
+def _type_name(name: str, version: int) -> str:
+    return f"{_pascalize(name)}V{version}"
+
+
+def _emit_model(domain: DomainDef, model_name: str, version: ModelVersion, out_dir: Path) -> EmittedArtifact:
+    artifact_id = _artifact_id(domain.name, model_name, version.version)
+    type_name = _type_name(model_name, version.version)
+    lines = _header_lines(_package_name(domain.name))
+    nested_definitions: dict[str, list[str]] = {}
+    warnings: list[str] = []
+
+    params: list[str] = []
+    for field in version.fields:
+        shape = TypeShape.from_field_type(field.type, optional=field.optional)
+        java_type = _shape_to_java(shape, owner_type=type_name, path=[field.name], definitions=nested_definitions)
+        params.append(f"    {java_type} {_field_name(field.name)}")
+    lines.append(f"public record {type_name}(")
+    lines.append(",\n".join(params))
+    lines.append(") {")
+    lines.extend(_render_nested_definitions(nested_definitions))
+    lines.append("}")
+
+    text = "\n".join(lines) + "\n"
+    return EmittedArtifact(
+        target="java",
+        ref=f"{domain.name}.{model_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / _java_path(domain.name, type_name),
+        content=text,
+        content_hash=compute_content_hash(text),
+        warnings=warnings,
+    )
+
+
+def _emit_projection(
+    domain: DomainDef,
+    projection_name: str,
+    version: ProjectionVersion,
+    out_dir: Path,
+    mdl,
+) -> EmittedArtifact:
+    artifact_id = _artifact_id(domain.name, projection_name, version.version)
+    type_name = _type_name(projection_name, version.version)
+    lines = _header_lines(_package_name(domain.name))
+    nested_definitions: dict[str, list[str]] = {}
+    warnings: list[str] = []
+
+    params: list[str] = []
+    for field in version.fields:
+        field_shape = _resolve_projection_field_shape(field, version, mdl)
+        if field_shape is None:
+            warnings.append(type_loss(f"{domain.name}.{projection_name}.{field.name}"))
+            java_type = "Object"
+        else:
+            java_type = _shape_to_java(
+                field_shape, owner_type=type_name, path=[field.name], definitions=nested_definitions
+            )
+        params.append(f"    {java_type} {_field_name(field.name)}")
+    lines.append(f"public record {type_name}(")
+    lines.append(",\n".join(params))
+    lines.append(") {")
+    lines.extend(_render_nested_definitions(nested_definitions))
+    lines.append("}")
+
+    text = "\n".join(lines) + "\n"
+    return EmittedArtifact(
+        target="java",
+        ref=f"{domain.name}.{projection_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / _java_path(domain.name, type_name),
+        content=text,
+        content_hash=compute_content_hash(text),
+        warnings=warnings,
+    )
+
+
+def _header_lines(package_name: str) -> list[str]:
+    return [
+        f"package {package_name};",
+        "",
+        "import java.math.BigDecimal;",
+        "import java.time.Duration;",
+        "import java.time.Instant;",
+        "import java.time.LocalDate;",
+        "import java.time.LocalTime;",
+        "import java.util.List;",
+        "import java.util.Map;",
+        "import java.util.Optional;",
+        "import java.util.UUID;",
+        "",
+    ]
+
+
+def _render_nested_definitions(definitions: dict[str, list[str]]) -> list[str]:
+    lines: list[str] = []
+    for definition in definitions.values():
+        lines.append("")
+        lines.extend(definition)
+    return lines
+
+
+def _field_name(value: str) -> str:
+    parts = [part for part in re.split(r"[^A-Za-z0-9]+", value) if part]
+    if not parts:
+        return "field"
+    first = parts[0][:1].lower() + parts[0][1:]
+    tail = "".join(part[:1].upper() + part[1:] for part in parts[1:])
+    return first + tail
+
+
+def _shape_to_java(
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+) -> str:
+    base = _shape_base_to_java(shape, owner_type=owner_type, path=path, definitions=definitions)
+    if shape.optional or shape.nullable:
+        return f"Optional<{base}>"
+    return base
+
+
+def _shape_base_to_java(
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+) -> str:
+    if shape.kind == "primitive":
+        return _primitive_to_java(shape.ref or "string")
+    if shape.kind == "decimal":
+        return "BigDecimal"
+    if shape.kind == "array":
+        element = shape.element or TypeShape(kind="primitive", ref="object")
+        return f"List<{_shape_to_java(element, owner_type=owner_type, path=[*path, 'Item'], definitions=definitions)}>"
+    if shape.kind == "map":
+        value = shape.value or TypeShape(kind="primitive", ref="object")
+        return f"Map<String, {_shape_to_java(value, owner_type=owner_type, path=[*path, 'Value'], definitions=definitions)}>"
+    if shape.kind == "ref":
+        return "String"
+    if shape.kind == "enum":
+        return "String"
+    if shape.kind == "named":
+        return _pascalize(shape.ref or "Named")
+    if shape.kind == "object":
+        type_name = _nested_type_name(path)
+        if type_name not in definitions:
+            definitions[type_name] = _build_record_definition(
+                type_name,
+                shape,
+                owner_type=owner_type,
+                path=path,
+                definitions=definitions,
+            )
+        return type_name
+    return "Object"
+
+
+def _primitive_to_java(kind: str) -> str:
+    mapping = {
+        "string": "String",
+        "bool": "Boolean",
+        "int": "Long",
+        "float": "Double",
+        "uuid": "UUID",
+        "timestamp": "Instant",
+        "date": "LocalDate",
+        "time": "LocalTime",
+        "duration": "Duration",
+        "binary": "byte[]",
+    }
+    return mapping.get(kind, "String")
+
+
+def _nested_type_name(path: list[str]) -> str:
+    return "".join(_pascalize(part) for part in path) or "Nested"
+
+
+def _build_record_definition(
+    type_name: str,
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+) -> list[str]:
+    lines = [f"    public record {type_name}("]
+    params: list[str] = []
+    for field in shape.fields:
+        child_shape = field.shape
+        child_type = _shape_to_java(
+            child_shape,
+            owner_type=owner_type,
+            path=[*path, field.name],
+            definitions=definitions,
+        )
+        params.append(f"        {child_type} {_field_name(field.name)}")
+    lines.append(",\n".join(params))
+    lines.append("    ) {}")
+    return lines
+
+
+def _resolve_projection_field_shape(field, projection: ProjectionVersion, mdl):
+    if not isinstance(field.mapping, DirectMapping):
+        return None
+    try:
+        source_domain, source_model = projection.source.model.rsplit(".", 1)
+    except ValueError:
+        return None
+    try:
+        resolved = resolve_model_ref(mdl, f"{source_domain}.{source_model}", projection.source.version)
+    except LookupError:
+        return None
+    source_mv = resolved.version
+    for src_field in source_mv.fields:
+        if src_field.name == field.mapping.source_field:
+            return TypeShape.from_field_type(src_field.type, optional=src_field.optional)
+    return None
+
+
+def _java_path(domain: str, type_name: str) -> Path:
+    return Path(*_package_name(domain).split(".")) / f"{type_name}.java"