modelable 1.0.0__py3-none-any.whl

modelable/compiler/workspace.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+
+from modelable.diagnostics.model import Diagnostic
+from modelable.expressions.cel import CelContext, parse_cel, validate_cel_expr
+from modelable.parser.ir import ComputedMapping, MdlFile
+from modelable.parser.parse import parse_text_to_ir
+from modelable.planner.planner import expand_auto_projections
+from modelable.registry.resolver import resolve_model_ref, validate_references
+from modelable.validation.semantic import validate_diagnostics
+
+
+@dataclass(frozen=True)
+class WorkspaceSource:
+    path: Path | None
+    uri: str
+    text: str
+    mdl: MdlFile
+    errors: list[Diagnostic]
+    content_hash: str
+
+
+@dataclass(frozen=True)
+class Workspace:
+    sources: list[WorkspaceSource]
+    mdl: MdlFile
+    errors: list[Diagnostic]
+
+
+@dataclass(frozen=True)
+class WorkspaceDocumentSource:
+    path: Path | None
+    uri: str
+    text: str
+
+
+def discover_mdl_files(path: str | Path) -> list[Path]:
+    """Return .mdl files from a file or directory in deterministic order."""
+    root = Path(path)
+    if root.is_file():
+        if root.suffix != ".mdl":
+            raise FileNotFoundError(f"{root} is not a .mdl file")
+        return [root]
+
+    files = sorted(root.rglob("*.mdl"), key=lambda item: item.as_posix())
+    if not files:
+        raise FileNotFoundError(f"No .mdl files found under {root}")
+    return files
+
+
+def load_workspace(path: str | Path) -> Workspace:
+    """Parse and validate all local .mdl files under path."""
+    sources = [
+        WorkspaceDocumentSource(
+            path=mdl_path,
+            uri=mdl_path.resolve().as_uri(),
+            text=mdl_path.read_text(encoding="utf-8"),
+        )
+        for mdl_path in discover_mdl_files(path)
+    ]
+    return load_workspace_from_sources(sources)
+
+
+def load_workspace_from_sources(sources: list[WorkspaceDocumentSource]) -> Workspace:
+    workspace_sources: list[WorkspaceSource] = []
+    errors: list[Diagnostic] = []
+    merged = MdlFile()
+
+    for source in sources:
+        source_location = str(source.path) if source.path is not None else source.uri
+        mdl = parse_text_to_ir(source.text, path=source_location)
+        source_errors = validate_diagnostics(mdl, path=source_location)
+        workspace_sources.append(
+            WorkspaceSource(
+                path=source.path,
+                uri=source.uri,
+                text=source.text,
+                mdl=mdl,
+                errors=source_errors,
+                content_hash=_content_hash(source.text),
+            )
+        )
+        errors.extend(source_errors)
+        merged.domains.extend(mdl.domains)
+        _merge_bindings(merged.bindings, mdl.bindings)
+        if mdl.workspace is not None:
+            merged.workspace = mdl.workspace
+
+    auto_projection_errors = expand_auto_projections(merged)
+    errors.extend(
+        Diagnostic(code="SEM", message=error, severity="error", path="<workspace>") for error in auto_projection_errors
+    )
+
+    errors.extend(_validate_merged_workspace(workspace_sources, merged))
+    errors.extend(_validate_cel(merged))
+    return Workspace(sources=workspace_sources, mdl=merged, errors=errors)
+
+
+def _validate_merged_workspace(sources: list[WorkspaceSource], merged: MdlFile) -> list[Diagnostic]:
+    errors: list[Diagnostic] = []
+    domains: dict[str, Path | None] = {}
+    model_versions: dict[tuple[str, str, int], Path | None] = {}
+    projection_versions: dict[tuple[str, str, int], Path | None] = {}
+    generated_projection_versions: dict[tuple[str, str, int], Path | None] = {}
+
+    for source in sources:
+        for domain in source.mdl.domains:
+            previous_domain_path = domains.get(domain.name)
+            if previous_domain_path is not None:
+                errors.append(
+                    Diagnostic(
+                        code="SEM",
+                        message=(f"duplicate domain '{domain.name}' also defined in {previous_domain_path}"),
+                        severity="error",
+                        path=str(source.path) if source.path is not None else source.uri,
+                    )
+                )
+            else:
+                domains[domain.name] = source.path
+
+            for model_name, versions in domain.models.items():
+                for version in versions:
+                    key = (domain.name, model_name, version.version)
+                    previous_model_path = model_versions.get(key)
+                    if previous_model_path is not None:
+                        errors.append(
+                            Diagnostic(
+                                code="SEM",
+                                message=(
+                                    "duplicate model version "
+                                    f"{domain.name}.{model_name}@{version.version} "
+                                    f"also defined in {previous_model_path}"
+                                ),
+                                severity="error",
+                                path=str(source.path) if source.path is not None else source.uri,
+                            )
+                        )
+                    else:
+                        model_versions[key] = source.path
+
+            for projection_name, versions in domain.projections.items():
+                for version in versions:
+                    # Skip auto-generated projections when checking for explicit
+                    # projection conflicts — they are validated separately.
+                    if version.auto_generated:
+                        continue
+                    key = (domain.name, projection_name, version.version)
+                    previous_projection_path = projection_versions.get(key)
+                    if previous_projection_path is not None:
+                        errors.append(
+                            Diagnostic(
+                                code="SEM",
+                                message=(
+                                    "duplicate projection version "
+                                    f"{domain.name}.{projection_name}@{version.version} "
+                                    f"also defined in {previous_projection_path}"
+                                ),
+                                severity="error",
+                                path=str(source.path) if source.path is not None else source.uri,
+                            )
+                        )
+                    else:
+                        projection_versions[key] = source.path
+
+            for auto_projection in domain.auto_projections:
+                for target in auto_projection.targets:
+                    projection_name = _generated_projection_name(auto_projection.model, target.kind)
+                    key = (domain.name, projection_name, auto_projection.version)
+
+                    previous_generated_path = generated_projection_versions.get(key)
+                    if previous_generated_path is not None:
+                        errors.append(
+                            Diagnostic(
+                                code="SEM",
+                                message=(
+                                    "generated projection name "
+                                    f"{domain.name}.{projection_name}@{auto_projection.version} "
+                                    f"conflicts with auto projection declared in "
+                                    f"{previous_generated_path}"
+                                ),
+                                severity="error",
+                                path=str(source.path) if source.path is not None else source.uri,
+                            )
+                        )
+                    else:
+                        generated_projection_versions[key] = source.path
+
+                    explicit_projection_path = projection_versions.get(key)
+                    if explicit_projection_path is not None:
+                        errors.append(
+                            Diagnostic(
+                                code="SEM",
+                                message=(
+                                    "generated projection name "
+                                    f"{domain.name}.{projection_name}@{auto_projection.version} "
+                                    f"conflicts with explicit projection declared in "
+                                    f"{explicit_projection_path}"
+                                ),
+                                severity="error",
+                                path=str(source.path) if source.path is not None else source.uri,
+                            )
+                        )
+
+    errors.extend(
+        Diagnostic(code="SEM", message=error, severity="error", path="<workspace>")
+        for error in validate_references(merged)
+    )
+    errors.extend(_validate_bindings(merged))
+    return errors
+
+
+def _merge_bindings(existing: list, incoming: list) -> None:
+    """Merge incoming bindings into existing, deduplicating identical definitions.
+
+    Two bindings are considered identical if they share the same name, adapter,
+    model, model_version, and table. Identical duplicates are silently dropped.
+    Conflicting duplicates (same name, different adapter) are kept so that
+    _validate_bindings can report them.
+    """
+    seen: set[tuple] = {(b.name, b.adapter, b.model, b.model_version, b.table) for b in existing}
+    for b in incoming:
+        key = (b.name, b.adapter, b.model, b.model_version, b.table)
+        if key not in seen:
+            existing.append(b)
+            seen.add(key)
+
+
+def _validate_bindings(merged: MdlFile) -> list[Diagnostic]:
+    """Detect binding names that appear with conflicting definitions."""
+    errors: list[Diagnostic] = []
+    seen: dict[str, str] = {}  # name → adapter
+    for b in merged.bindings:
+        if b.name in seen:
+            if seen[b.name] != b.adapter:
+                errors.append(
+                    Diagnostic(
+                        code="SEM",
+                        message=(
+                            f"binding '{b.name}' is declared with conflicting adapter "
+                            f"'{b.adapter}' (previously '{seen[b.name]}')"
+                        ),
+                        severity="error",
+                        path="<workspace>",
+                    )
+                )
+        else:
+            seen[b.name] = b.adapter
+    return errors
+
+
+def _validate_cel(merged: MdlFile) -> list[Diagnostic]:
+    """Validate CEL expressions in all projections across the merged workspace."""
+    errors: list[Diagnostic] = []
+
+    for domain in merged.domains:
+        for projection_name, versions in domain.projections.items():
+            for pv in versions:
+                fqn = f"{domain.name}.{projection_name}@{pv.version}"
+
+                # Build alias -> set[field_name] from source and all joins
+                source_fields: dict[str, set[str]] = {}
+                all_sources = [(pv.source.model, pv.source.version, pv.source.alias)]
+                for join in pv.joins:
+                    all_sources.append((join.model, join.version, join.alias))
+                for model_ref, version_spec, alias in all_sources:
+                    try:
+                        resolved = resolve_model_ref(merged, model_ref, version_spec)
+                        source_fields[alias] = {f.name for f in resolved.version.fields}
+                    except LookupError:
+                        pass
+
+                ctx = CelContext(
+                    source_fields=source_fields,
+                    has_group_by=bool(pv.group_by),
+                    fqn=fqn,
+                )
+
+                for proj_field in pv.fields:
+                    if not isinstance(proj_field.mapping, ComputedMapping):
+                        continue
+                    expression = proj_field.mapping.expression
+                    ast, parse_errors = parse_cel(expression)
+                    for err in parse_errors:
+                        errors.append(
+                            Diagnostic(
+                                code="CEL",
+                                message=f"{fqn}.{proj_field.name}: {err}",
+                                severity="error",
+                                path="<workspace>",
+                            )
+                        )
+                    if ast is not None:
+                        result = validate_cel_expr(ast, ctx)
+                        for err in result.errors:
+                            errors.append(
+                                Diagnostic(
+                                    code="CEL",
+                                    message=f"{proj_field.name}: {err}",
+                                    severity="error",
+                                    path="<workspace>",
+                                )
+                            )
+
+                for join in pv.joins:
+                    if not join.on:
+                        continue
+                    ast, parse_errors = parse_cel(join.on)
+                    for err in parse_errors:
+                        errors.append(
+                            Diagnostic(
+                                code="CEL",
+                                message=f"{fqn} join on: {err}",
+                                severity="error",
+                                path="<workspace>",
+                            )
+                        )
+                    if ast is not None:
+                        result = validate_cel_expr(ast, ctx)
+                        for err in result.errors:
+                            errors.append(
+                                Diagnostic(
+                                    code="CEL",
+                                    message=f"{fqn} join on: {err}",
+                                    severity="error",
+                                    path="<workspace>",
+                                )
+                            )
+
+    return errors
+
+
+def _generated_projection_name(model_name: str, kind: str) -> str:
+    suffixes = {
+        "db": "Db",
+        "request": "Request",
+        "reply": "Reply",
+        "event": "Event",
+    }
+    return f"{model_name}{suffixes[kind]}"
+
+
+def _content_hash(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()

modelable/diagnostics/__init__.py

@@ -0,0 +1,3 @@
+from modelable.diagnostics.model import Diagnostic, DiagnosticSeverity, render_diagnostic
+
+__all__ = ["Diagnostic", "DiagnosticSeverity", "render_diagnostic"]

modelable/diagnostics/model.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+DiagnosticSeverity = Literal["error", "warning", "information"]
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    code: str
+    message: str
+    severity: DiagnosticSeverity
+    path: str
+    line: int | None = None
+    column: int | None = None
+    end_line: int | None = None
+    end_column: int | None = None
+
+
+def render_diagnostic(diagnostic: Diagnostic) -> str:
+    location = diagnostic.path
+    if diagnostic.line is not None:
+        location += f":{diagnostic.line}"
+        if diagnostic.column is not None:
+            location += f":{diagnostic.column}"
+    return f"{diagnostic.code}: {location}: {diagnostic.message}"

modelable/emitters/base.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class EmittedArtifact:
+    target: str
+    ref: str  # "domain.Name@version"
+    artifact_id: str  # "domain.Name.vVersion"
+    path: Path
+    content: dict[str, object] | str
+    content_hash: str
+    warnings: list[str] = field(default_factory=list)
+
+
+def compute_content_hash(content: dict[str, object] | str) -> str:
+    payload = json.dumps(content, indent=2, ensure_ascii=False) + "\n" if isinstance(content, dict) else content
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()

modelable/emitters/csharp.py

@@ -0,0 +1,245 @@
+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_csharp(workspace: Workspace, out_dir: Path) -> list[EmittedArtifact]:
+    """Emit C# 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 _namespace_name(domain: str) -> str:
+    return f"Modelable.{_pascalize(domain)}"
+
+
+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)
+    lines = _header_lines(_namespace_name(domain.name))
+    nested_definitions: dict[str, list[str]] = {}
+    warnings: list[str] = []
+
+    lines.append(f"public sealed record {type_name}")
+    lines.append("{")
+    for field in version.fields:
+        shape = TypeShape.from_field_type(field.type, optional=field.optional)
+        csharp_type = _shape_to_csharp(shape, owner_type=type_name, path=[field.name], definitions=nested_definitions)
+        prefix = "required " if not (shape.optional or shape.nullable) else ""
+        lines.append(f"    public {prefix}{csharp_type} {_property_name(field.name)} {{ get; init; }}")
+    lines.append("}")
+    lines.extend(_render_nested_definitions(nested_definitions))
+
+    text = "\n".join(lines) + "\n"
+    return EmittedArtifact(
+        target="csharp",
+        ref=f"{domain.name}.{model_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / f"{artifact_id}.cs",
+        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 = _stable_type_name(domain.name, projection_name, version.version)
+    lines = _header_lines(_namespace_name(domain.name))
+    nested_definitions: dict[str, list[str]] = {}
+    warnings: list[str] = []
+
+    lines.append(f"public sealed record {type_name}")
+    lines.append("{")
+    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}"))
+            csharp_type = "object"
+            prefix = "required "
+        else:
+            csharp_type = _shape_to_csharp(
+                field_shape, owner_type=type_name, path=[field.name], definitions=nested_definitions
+            )
+            prefix = "required " if not (field_shape.optional or field_shape.nullable) else ""
+        lines.append(f"    public {prefix}{csharp_type} {_property_name(field.name)} {{ get; init; }}")
+    lines.append("}")
+    lines.extend(_render_nested_definitions(nested_definitions))
+
+    text = "\n".join(lines) + "\n"
+    return EmittedArtifact(
+        target="csharp",
+        ref=f"{domain.name}.{projection_name}@{version.version}",
+        artifact_id=artifact_id,
+        path=out_dir / f"{artifact_id}.cs",
+        content=text,
+        content_hash=compute_content_hash(text),
+        warnings=warnings,
+    )
+
+
+def _header_lines(namespace: str) -> list[str]:
+    return [
+        "#nullable enable",
+        "using System;",
+        "using System.Collections.Generic;",
+        "",
+        f"namespace {namespace};",
+        "",
+    ]
+
+
+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 _property_name(value: str) -> str:
+    return _pascalize(value)
+
+
+def _shape_to_csharp(
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+) -> str:
+    base = _shape_base_to_csharp(shape, owner_type=owner_type, path=path, definitions=definitions)
+    if shape.optional or shape.nullable:
+        return f"{base}?"
+    return base
+
+
+def _shape_base_to_csharp(
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+) -> str:
+    if shape.kind == "primitive":
+        return _primitive_to_csharp(shape.ref or "string")
+    if shape.kind == "decimal":
+        return "decimal"
+    if shape.kind == "array":
+        element = shape.element or TypeShape(kind="primitive", ref="object")
+        return (
+            f"List<{_shape_to_csharp(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"Dictionary<string, {_shape_to_csharp(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(owner_type, 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_csharp(kind: str) -> str:
+    mapping = {
+        "string": "string",
+        "bool": "bool",
+        "int": "int",
+        "float": "double",
+        "uuid": "Guid",
+        "timestamp": "DateTime",
+        "date": "DateOnly",
+        "time": "TimeOnly",
+        "duration": "TimeSpan",
+        "binary": "byte[]",
+    }
+    return mapping.get(kind, "string")
+
+
+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 _build_record_definition(
+    type_name: str,
+    shape: TypeShape,
+    *,
+    owner_type: str,
+    path: list[str],
+    definitions: dict[str, list[str]],
+) -> list[str]:
+    lines = [f"public sealed record {type_name}", "{"]
+    for field in shape.fields:
+        child_shape = field.shape
+        child_type = _shape_to_csharp(
+            child_shape,
+            owner_type=owner_type,
+            path=[*path, field.name],
+            definitions=definitions,
+        )
+        prefix = "required " if not (child_shape.optional or child_shape.nullable) else ""
+        lines.append(f"    public {prefix}{child_type} {_property_name(field.name)} {{ get; init; }}")
+    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