modelable 1.0.0__py3-none-any.whl

modelable/emitters/fhir.py

@@ -0,0 +1,694 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from modelable.compiler.workspace import Workspace
+from modelable.emitters.base import EmittedArtifact, compute_content_hash
+from modelable.parser.ir import (
+    AnnClassification,
+    AnnPii,
+    ArrayType,
+    DecimalType,
+    DirectMapping,
+    DomainDef,
+    EnumType,
+    FieldDef,
+    FieldType,
+    MdlFile,
+    NamedType,
+    ObjectType,
+    PrimitiveType,
+    ProjectionField,
+    ProjectionVersion,
+    RefType,
+)
+from modelable.registry.resolver import ResolvedModelRef, resolve_model_ref
+
+FHIR_R4_VERSION = "4.0.1"
+FHIR_STRUCTURE_DEFINITION_BASE = "http://hl7.org/fhir/StructureDefinition"
+MODELABLE_STRUCTURE_DEFINITION_BASE = "http://modelable.io/fhir/StructureDefinition"
+MODELABLE_VALUE_SET_BASE = "http://modelable.io/fhir/ValueSet"
+SUPPORTED_BASE_RESOURCES = {"Encounter", "Observation", "Patient"}
+
+_BASE_RESOURCE_ELEMENTS: dict[str, frozenset[str]] = {
+    "Patient": frozenset(
+        {
+            "id",
+            "meta",
+            "implicitRules",
+            "language",
+            "text",
+            "contained",
+            "extension",
+            "modifierExtension",
+            "identifier",
+            "active",
+            "name",
+            "telecom",
+            "gender",
+            "birthDate",
+            "deceased[x]",
+            "address",
+            "maritalStatus",
+            "multipleBirth[x]",
+            "photo",
+            "contact",
+            "communication",
+            "generalPractitioner",
+            "managingOrganization",
+            "link",
+        }
+    ),
+    "Observation": frozenset(
+        {
+            "id",
+            "meta",
+            "implicitRules",
+            "language",
+            "text",
+            "contained",
+            "extension",
+            "modifierExtension",
+            "identifier",
+            "basedOn",
+            "partOf",
+            "status",
+            "category",
+            "code",
+            "subject",
+            "focus",
+            "encounter",
+            "effective[x]",
+            "issued",
+            "performer",
+            "value[x]",
+            "dataAbsentReason",
+            "interpretation",
+            "note",
+            "bodySite",
+            "method",
+            "specimen",
+            "device",
+            "referenceRange",
+            "hasMember",
+            "derivedFrom",
+            "component",
+        }
+    ),
+    "Encounter": frozenset(
+        {
+            "id",
+            "meta",
+            "implicitRules",
+            "language",
+            "text",
+            "contained",
+            "extension",
+            "modifierExtension",
+            "identifier",
+            "status",
+            "statusHistory",
+            "class",
+            "classHistory",
+            "type",
+            "serviceType",
+            "priority",
+            "subject",
+            "episodeOfCare",
+            "basedOn",
+            "participant",
+            "appointment",
+            "period",
+            "length",
+            "reasonCode",
+            "reasonReference",
+            "diagnosis",
+            "account",
+            "hospitalization",
+            "location",
+            "serviceProvider",
+            "partOf",
+        }
+    ),
+    "Basic": frozenset(
+        {
+            "id",
+            "meta",
+            "implicitRules",
+            "language",
+            "text",
+            "contained",
+            "extension",
+            "modifierExtension",
+            "identifier",
+            "code",
+            "subject",
+            "created",
+            "author",
+        }
+    ),
+}
+
+
+def emit_fhir_profile(workspace: Workspace, out_dir: Path) -> list[EmittedArtifact]:
+    """Emit FHIR R4 StructureDefinition profiles and companion Extension SDs."""
+    artifacts: list[EmittedArtifact] = []
+    for domain in workspace.mdl.domains:
+        for projection_name, versions in domain.projections.items():
+            for version in versions:
+                result = _emit_projection(domain, projection_name, version, workspace.mdl, out_dir)
+                artifacts.append(result["profile"])
+                artifacts.extend(result["extensions"])
+    return artifacts
+
+
+def _emit_projection(
+    domain: DomainDef,
+    projection_name: str,
+    version: ProjectionVersion,
+    mdl: MdlFile,
+    out_dir: Path,
+) -> dict[str, object]:
+    artifact_id = _artifact_id(domain.name, projection_name, version.version)
+    source = _resolve_source(mdl, version)
+    base_resource, warnings = _base_resource(source)
+
+    ext_fields = [f for f in version.fields if _is_extension_field(base_resource, f)]
+    direct_fields = [f for f in version.fields if not _is_extension_field(base_resource, f)]
+    elements = _elements(domain, projection_name, version, source, base_resource, ext_fields, direct_fields)
+
+    struct_def: dict[str, object] = {
+        "resourceType": "StructureDefinition",
+        "url": f"{MODELABLE_STRUCTURE_DEFINITION_BASE}/{artifact_id}",
+        "version": str(version.version),
+        "name": projection_name,
+        "title": projection_name,
+        "status": "draft",
+        "fhirVersion": FHIR_R4_VERSION,
+        "kind": "resource",
+        "abstract": False,
+        "type": base_resource,
+        "baseDefinition": f"{FHIR_STRUCTURE_DEFINITION_BASE}/{base_resource}",
+        "derivation": "constraint",
+        "mapping": [
+            {
+                "identity": "modelable",
+                "uri": "https://github.com/ktjn/modelable",
+                "name": "Modelable",
+            }
+        ],
+        "snapshot": {"element": elements},
+        "differential": {"element": elements},
+    }
+    _add_domain_metadata(struct_def, domain)
+
+    content = json.dumps(struct_def, indent=2, ensure_ascii=False) + "\n"
+    profile = EmittedArtifact(
+        target="fhir-profile",
+        ref=f"{domain.name}.{projection_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / f"{artifact_id}.fhir.json",
+        content=content,
+        content_hash=compute_content_hash(content),
+        warnings=warnings,
+    )
+
+    extension_artifacts = [
+        _emit_extension_sd(domain, projection_name, version.version, field, source, out_dir) for field in ext_fields
+    ]
+
+    return {"profile": profile, "extensions": extension_artifacts}
+
+
+def _is_extension_field(base_resource: str, field: ProjectionField) -> bool:
+    elements = _BASE_RESOURCE_ELEMENTS.get(base_resource)
+    if elements is None:
+        return True
+    return field.name not in elements
+
+
+def _artifact_id(domain: str, name: str, version: int) -> str:
+    return f"{domain}.{name}.v{version}"
+
+
+def _add_domain_metadata(struct_def: dict[str, object], domain: DomainDef) -> None:
+    if domain.owner is not None:
+        struct_def["publisher"] = domain.owner
+    if domain.contact is not None:
+        struct_def["contact"] = [{"telecom": [{"system": "email", "value": domain.contact}]}]
+    if domain.description is not None:
+        struct_def["description"] = domain.description
+
+
+def _resolve_source(mdl: MdlFile, projection: ProjectionVersion) -> ResolvedModelRef | None:
+    try:
+        return resolve_model_ref(mdl, projection.source.model, projection.source.version)
+    except LookupError:
+        return None
+
+
+def _base_resource(source: ResolvedModelRef | None) -> tuple[str, list[str]]:
+    if source is None:
+        return "Basic", ["FHIR profile source model could not be resolved; using Basic as the base resource"]
+    resource = source.model_name
+    if resource in SUPPORTED_BASE_RESOURCES:
+        return resource, []
+    supported = ", ".join(sorted(SUPPORTED_BASE_RESOURCES))
+    return "Basic", [f"FHIR profile base resource '{resource}' is not in the supported R4 set: {supported}"]
+
+
+def _elements(
+    domain: DomainDef,
+    projection_name: str,
+    projection: ProjectionVersion,
+    source: ResolvedModelRef | None,
+    base_resource: str,
+    ext_fields: list[ProjectionField],
+    direct_fields: list[ProjectionField],
+) -> list[dict[str, object]]:
+    root = {
+        "id": base_resource,
+        "path": base_resource,
+        "min": 0,
+        "max": "*",
+        "base": {"path": base_resource, "min": 0, "max": "*"},
+        "definition": (
+            f"Modelable projection {domain.name}.{projection_name}@{projection.version} constrained from "
+            f"{projection.source.model}@{_version_label(projection)}."
+        ),
+    }
+    elements: list[dict[str, object]] = [root]
+    for field in direct_fields:
+        elements.append(_field_element(domain, projection_name, projection, field, source, base_resource))
+    if ext_fields:
+        elements.append(_extension_slicing_element(base_resource))
+        for field in ext_fields:
+            source_field = _source_field(field, source)
+            field_type = source_field.type if source_field is not None else PrimitiveType(kind="string")
+            elements.append(
+                _extension_slice_element(domain, projection_name, projection, field, source, base_resource, field_type)
+            )
+            if not isinstance(field_type, ObjectType):
+                elements.append(
+                    _extension_value_element(
+                        domain.name, projection_name, field, field_type, base_resource, source_field=source_field
+                    )
+                )
+    return elements
+
+
+def _field_element(
+    domain: DomainDef,
+    projection_name: str,
+    projection: ProjectionVersion,
+    field: ProjectionField,
+    source: ResolvedModelRef | None,
+    base_resource: str,
+) -> dict[str, object]:
+    source_field = _source_field(field, source)
+    field_type = source_field.type if source_field is not None else PrimitiveType(kind="string")
+    path = f"{base_resource}.{field.name}"
+    max_occurs = _max_occurs(field_type)
+    element: dict[str, object] = {
+        "id": path,
+        "path": path,
+        "min": 0 if source_field is not None and source_field.optional else 1,
+        "max": max_occurs,
+        "base": {"path": path, "min": 0, "max": max_occurs},
+        "definition": f"Modelable field {field.name}.",
+        "type": _fhir_type(field_type, source_field=source_field),
+    }
+
+    binding = _binding(domain.name, projection_name, field.name, field_type)
+    if binding is not None:
+        element["binding"] = binding
+
+    extensions = _extensions(field, source_field)
+    if extensions:
+        element["extension"] = extensions
+
+    lineage = _lineage_mapping(field, projection, source)
+    if lineage is not None:
+        element["mapping"] = [{"identity": "modelable", "map": lineage}]
+
+    return element
+
+
+def _source_field(field: ProjectionField, source: ResolvedModelRef | None) -> FieldDef | None:
+    if source is None or not isinstance(field.mapping, DirectMapping):
+        return None
+    return next(
+        (source_field for source_field in source.version.fields if source_field.name == field.mapping.source_field),
+        None,
+    )
+
+
+def _fhir_type(field_type: FieldType, *, source_field: FieldDef | None = None) -> list[dict[str, object]]:
+    if source_field is not None:
+        wire_type = _wire_fhir_type_override(source_field)
+        if wire_type is not None:
+            return [{"code": wire_type}]
+    if isinstance(field_type, PrimitiveType):
+        return [{"code": _primitive_type(field_type.kind)}]
+    if isinstance(field_type, DecimalType):
+        return [{"code": "decimal"}]
+    if isinstance(field_type, EnumType):
+        return [{"code": "code"}]
+    if isinstance(field_type, RefType):
+        target = field_type.target.rsplit(".", 1)[-1]
+        return [
+            {
+                "code": "Reference",
+                "targetProfile": [f"{FHIR_STRUCTURE_DEFINITION_BASE}/{target}"],
+            }
+        ]
+    if isinstance(field_type, ArrayType):
+        return _fhir_type(field_type.item)
+    if isinstance(field_type, (NamedType, ObjectType)):
+        return [{"code": "BackboneElement"}]
+    return [{"code": "string"}]
+
+
+def _wire_fhir_type_override(field: FieldDef) -> str | None:
+    wire = field.wire_targets().get("fhir")
+    if wire is not None:
+        if getattr(wire, "type", None) is not None:
+            return wire.type
+        encoding = getattr(wire, "encoding", None)
+        if encoding is not None:
+            _encoding_map = {
+                "string": "string",
+                "integer": "integer",
+                "boolean": "boolean",
+                "decimal": "decimal",
+                "dateTime": "dateTime",
+                "uri": "uri",
+                "code": "code",
+            }
+            return _encoding_map.get(encoding)
+    return None
+
+
+def _max_occurs(field_type: FieldType) -> str:
+    if isinstance(field_type, ArrayType):
+        return "*"
+    return "1"
+
+
+def _primitive_type(kind: str) -> str:
+    mapping = {
+        "binary": "base64Binary",
+        "bool": "boolean",
+        "date": "date",
+        "duration": "Duration",
+        "float": "decimal",
+        "int": "integer",
+        "json": "string",
+        "string": "string",
+        "time": "time",
+        "timestamp": "dateTime",
+        "uuid": "string",
+    }
+    return mapping.get(kind, "string")
+
+
+def _binding(domain_name: str, projection_name: str, field_name: str, field_type: FieldType) -> dict[str, str] | None:
+    if not isinstance(field_type, EnumType):
+        return None
+    return {
+        "strength": "required",
+        "valueSet": f"{MODELABLE_VALUE_SET_BASE}/{domain_name}.{projection_name}.{field_name}",
+    }
+
+
+def _extensions(field: ProjectionField, source_field: FieldDef | None) -> list[dict[str, object]]:
+    annotations = [*(source_field.annotations if source_field is not None else []), *field.annotations]
+    classification_extensions: list[dict[str, object]] = []
+    pii_extensions: list[dict[str, object]] = []
+    for annotation in annotations:
+        if isinstance(annotation, AnnClassification):
+            classification_extensions.append(
+                {
+                    "url": f"{MODELABLE_STRUCTURE_DEFINITION_BASE}/classification",
+                    "valueCode": annotation.level,
+                }
+            )
+        elif isinstance(annotation, AnnPii):
+            pii_extensions.append(
+                {
+                    "url": f"{MODELABLE_STRUCTURE_DEFINITION_BASE}/pii",
+                    "valueBoolean": True,
+                }
+            )
+    return [*classification_extensions, *pii_extensions]
+
+
+def _lineage_mapping(
+    field: ProjectionField,
+    projection: ProjectionVersion,
+    source: ResolvedModelRef | None,
+) -> str | None:
+    if source is None or not isinstance(field.mapping, DirectMapping):
+        return None
+    return f"{projection.source.model}@{source.version.version}.{field.mapping.source_field}"
+
+
+def _extension_artifact_id(domain_name: str, projection_name: str, version: int, field_name: str) -> str:
+    return f"{domain_name}.{projection_name}.v{version}.ext.{field_name}"
+
+
+def _extension_slicing_element(base_resource: str) -> dict[str, object]:
+    return {
+        "id": f"{base_resource}.extension",
+        "path": f"{base_resource}.extension",
+        "min": 0,
+        "max": "*",
+        "slicing": {
+            "discriminator": [{"type": "value", "path": "url"}],
+            "ordered": False,
+            "rules": "open",
+        },
+    }
+
+
+def _extension_slice_element(
+    domain: DomainDef,
+    projection_name: str,
+    projection: ProjectionVersion,
+    field: ProjectionField,
+    source: ResolvedModelRef | None,
+    base_resource: str,
+    field_type: FieldType,
+) -> dict[str, object]:
+    source_field = _source_field(field, source)
+    ext_id = _extension_artifact_id(domain.name, projection_name, projection.version, field.name)
+    max_occurs = _max_occurs(field_type)
+    element: dict[str, object] = {
+        "id": f"{base_resource}.extension:{field.name}",
+        "path": f"{base_resource}.extension",
+        "sliceName": field.name,
+        "min": 0 if source_field is not None and source_field.optional else 1,
+        "max": max_occurs,
+        "type": [
+            {
+                "code": "Extension",
+                "profile": [f"{MODELABLE_STRUCTURE_DEFINITION_BASE}/{ext_id}"],
+            }
+        ],
+        "definition": f"Modelable field {field.name} (extension).",
+    }
+
+    extensions = _extensions(field, source_field)
+    if extensions:
+        element["extension"] = extensions
+
+    lineage = _lineage_mapping(field, projection, source)
+    if lineage is not None:
+        element["mapping"] = [{"identity": "modelable", "map": lineage}]
+
+    return element
+
+
+def _extension_value_element(
+    domain_name: str,
+    projection_name: str,
+    field: ProjectionField,
+    field_type: FieldType,
+    base_resource: str,
+    *,
+    source_field: FieldDef | None = None,
+) -> dict[str, object]:
+    max_occurs = _max_occurs(field_type)
+    element: dict[str, object] = {
+        "id": f"{base_resource}.extension:{field.name}.value[x]",
+        "path": f"{base_resource}.extension.value[x]",
+        "min": 1,
+        "max": max_occurs,
+        "type": _fhir_type(field_type, source_field=source_field),
+    }
+
+    element["definition"] = f"Modelable field {field.name} extension value."
+
+    binding = _binding(domain_name, projection_name, field.name, field_type)
+    if binding is not None:
+        element["binding"] = binding
+
+    return element
+
+
+def _extension_sd_value_element(
+    domain_name: str,
+    projection_name: str,
+    field: ProjectionField,
+    field_type: FieldType,
+    *,
+    source_field: FieldDef | None = None,
+) -> dict[str, object]:
+    max_occurs = _max_occurs(field_type)
+    element: dict[str, object] = {
+        "id": "Extension.value[x]",
+        "path": "Extension.value[x]",
+        "min": 1,
+        "max": max_occurs,
+        "type": _fhir_type(field_type, source_field=source_field),
+    }
+
+    element["definition"] = f"Modelable field {field.name} extension value."
+
+    binding = _binding(domain_name, projection_name, field.name, field_type)
+    if binding is not None:
+        element["binding"] = binding
+
+    return element
+
+
+def _extension_sd_sub_extension_elements(
+    domain_name: str,
+    projection_name: str,
+    field: ProjectionField,
+    source_field: FieldDef | None,
+    ext_id: str,
+    parent_ext_url: str,
+) -> list[dict[str, object]]:
+    if source_field is None or not isinstance(source_field.type, ObjectType):
+        field_type = source_field.type if source_field is not None else PrimitiveType(kind="string")
+        return [_extension_sd_value_element(domain_name, projection_name, field, field_type, source_field=source_field)]
+
+    obj_type = source_field.type
+    sub_elements: list[dict[str, object]] = [
+        {
+            "id": "Extension.extension",
+            "path": "Extension.extension",
+            "min": 0,
+            "max": "*",
+            "slicing": {
+                "discriminator": [{"type": "value", "path": "url"}],
+                "ordered": False,
+                "rules": "open",
+            },
+        },
+    ]
+    for sub_field in obj_type.fields:
+        sub_url = f"{parent_ext_url}#{sub_field.name}"
+        sub_fhir_type = _fhir_type(sub_field.type, source_field=sub_field)
+        sub_max = _max_occurs(sub_field.type)
+        slice_id = f"Extension.extension:{sub_field.name}"
+        sub_elements.append(
+            {
+                "id": slice_id,
+                "path": "Extension.extension",
+                "sliceName": sub_field.name,
+                "min": 0 if sub_field.optional else 1,
+                "max": sub_max,
+                "type": [{"code": "Extension"}],
+                "definition": f"Modelable sub-field {field.name}.{sub_field.name}.",
+            }
+        )
+        sub_elements.append(
+            {
+                "id": f"{slice_id}.url",
+                "path": "Extension.extension.url",
+                "min": 1,
+                "max": "1",
+                "fixedUri": sub_url,
+            }
+        )
+        sub_elements.append(
+            {
+                "id": f"{slice_id}.value[x]",
+                "path": "Extension.extension.value[x]",
+                "min": 1,
+                "max": sub_max,
+                "type": sub_fhir_type,
+                "definition": f"Modelable sub-field {field.name}.{sub_field.name} value.",
+            }
+        )
+    return sub_elements
+
+
+def _emit_extension_sd(
+    domain: DomainDef,
+    projection_name: str,
+    version_num: int,
+    field: ProjectionField,
+    source: ResolvedModelRef | None,
+    out_dir: Path,
+) -> EmittedArtifact:
+    source_field = _source_field(field, source)
+    ext_id = _extension_artifact_id(domain.name, projection_name, version_num, field.name)
+    ext_url = f"{MODELABLE_STRUCTURE_DEFINITION_BASE}/{ext_id}"
+    sd_name = f"{projection_name}{field.name[0].upper() + field.name[1:] if field.name else field.name}"
+
+    elements: list[dict[str, object]] = [
+        {
+            "id": "Extension",
+            "path": "Extension",
+            "definition": f"Modelable extension for {domain.name}.{projection_name}.{field.name}.",
+        },
+        {
+            "id": "Extension.url",
+            "path": "Extension.url",
+            "min": 1,
+            "max": "1",
+            "fixedUri": ext_url,
+        },
+    ]
+    elements.extend(
+        _extension_sd_sub_extension_elements(domain.name, projection_name, field, source_field, ext_id, ext_url)
+    )
+
+    struct_def: dict[str, object] = {
+        "resourceType": "StructureDefinition",
+        "url": ext_url,
+        "version": str(version_num),
+        "name": sd_name,
+        "title": f"{projection_name} {field.name}",
+        "status": "draft",
+        "fhirVersion": FHIR_R4_VERSION,
+        "kind": "complex-type",
+        "abstract": False,
+        "type": "Extension",
+        "derivation": "specialization",
+        "snapshot": {"element": elements},
+        "differential": {"element": elements},
+    }
+    _add_domain_metadata(struct_def, domain)
+
+    content = json.dumps(struct_def, indent=2, ensure_ascii=False) + "\n"
+    return EmittedArtifact(
+        target="fhir-extension",
+        ref=f"{domain.name}.{projection_name}@{version_num}.{field.name}",
+        artifact_id=ext_id,
+        path=out_dir / f"{ext_id}.fhir.json",
+        content=content,
+        content_hash=compute_content_hash(content),
+        warnings=[],
+    )
+
+
+def _version_label(projection: ProjectionVersion) -> str:
+    version = projection.source.version
+    if hasattr(version, "version"):
+        return str(version.version)
+    return str(version)