Files
mizan/protocol/mizan-codegen/tests/fixtures/afi_ir.kdl
Ryth Azhur 45bde51166 Mizan-Rust backend adapter: server-side substrate + three-way parity
Adds first-class Rust-backed Mizan to sit alongside mizan-django and
mizan-fastapi. A Rust dev writes:

    #[derive(Mizan, Serialize, Deserialize)]
    pub struct ProfileOutput { pub user_id: i64, pub name: String }

    #[mizan::context("user")]
    pub struct UserCtx;

    #[mizan::client(context = UserCtx)]
    pub async fn user_profile(_req: &RequestHandle<'_>, user_id: i64) -> ProfileOutput { ... }

…and gets byte-identical KDL to the Python emitters, served over the
same wire protocol the React / Rust / Vue / Svelte kernels speak.

New crates:
- cores/mizan-rust/         (Cargo: mizan-core)     — IR types, KDL emitter, traits, registry,
                                                       runtime (compute_invalidation / compute_merges
                                                       ported from mizan-fastapi), graph_check with
                                                       structural type-matching
- cores/mizan-rust-macros/  (Cargo: mizan-macros)   — #[derive(Mizan)], #[mizan::context],
                                                       #[mizan::client] proc macros
- backends/mizan-rust-axum/ (Cargo: mizan-axum)     — axum HTTP adapter: /session/, /call/, /ctx/:name/
- tests/afi/rust_app/                                — AFI fixture port + server / export-ir binaries

Substrate-shape moves required by cross-language equivalence:
- IR canonicalization: functions / contexts / context-members / shared-by
  now sort alphabetically in both Python and Rust emitters. The IR is a
  contract; linkme doesn't preserve declaration order, so canonical sort
  is the only stable mapping. afi_ir.kdl + per-target baselines regenerated.
- MizanType::TYPE_NAME is a const (with a default type_name() reader) so
  it's usable in linkme TypeEntry static initializers.
- Tree-shaken type registry: #[derive(Mizan)] only emits the trait impl;
  the #[mizan::client] macro registers canonical-named entries from
  fn signatures, including Vec<T> element types for ref resolution.
- Merge resolution is structural (NamedType shape comparison) rather than
  by name — matches the Python types_match_for_merge semantics.

Three-way forcing functions:
- tests/afi/test_codegen_parity.py — Django ≡ FastAPI ≡ Rust on KDL bytes (3 pass)
- tests/rust/run_wire_parity.py    — 12/12 probes against FastAPI + Rust (EXIT=0)

Incidental fixes surfaced by the new tests:
- Stale `from .registry import validate_registry` import removed from
  mizan-django/setup/discovery.py (referenced a function that no longer
  exists; was masking codegen-parity).
- BASE_DIR added to tests/afi/django_app/project/settings.py.
- /session/ endpoint added to mizan-fastapi for protocol-shaped readiness
  probe parity (wire-parity harness now polls /api/mizan/session/ on both
  backends rather than FastAPI's /openapi.json).
- Root .gitignore picks up Rust target/ across the tree so new crates
  don't need per-crate gitignore.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-17 22:31:26 -04:00

188 lines
3.3 KiB
Plaintext

type "OrderOutput" {
struct {
field "id" {
primitive "integer"
}
field "user_id" {
primitive "integer"
}
field "total" {
primitive "integer"
}
}
}
type "echoInput" {
struct {
field "text" {
primitive "string"
}
}
}
type "echoOutput" {
struct {
field "message" {
primitive "string"
}
}
}
type "findUserInput" {
struct {
field "user_id" {
primitive "integer"
}
}
}
type "findUserOutput" {
struct {
field "user_id" {
primitive "integer"
}
field "name" {
primitive "string"
}
}
}
type "renameUserInput" {
struct {
field "user_id" {
primitive "integer"
}
field "name" {
primitive "string"
}
}
}
type "renameUserOutput" {
struct {
field "user_id" {
primitive "integer"
}
field "name" {
primitive "string"
}
}
}
type "updateProfileInput" {
struct {
field "user_id" {
primitive "integer"
}
field "name" {
primitive "string"
}
}
}
type "updateProfileOutput" {
struct {
field "ok" {
primitive "boolean"
}
}
}
type "userOrdersInput" {
struct {
field "user_id" {
primitive "integer"
}
}
}
type "userOrdersOutput" {
alias {
list {
ref "OrderOutput"
}
}
}
type "userProfileInput" {
struct {
field "user_id" {
primitive "integer"
}
}
}
type "userProfileOutput" {
struct {
field "user_id" {
primitive "integer"
}
field "name" {
primitive "string"
}
}
}
type "whoamiOutput" {
struct {
field "email" {
primitive "string"
}
field "authenticated" {
primitive "boolean"
}
}
}
function "echo" {
camel "echo"
has-input #true
input "echoInput"
output "echoOutput"
transport "http"
}
function "find_user" {
camel "findUser"
has-input #true
input "findUserInput"
output "findUserOutput"
output-nullable #true
transport "http"
}
function "rename_user" {
camel "renameUser"
has-input #true
input "renameUserInput"
output "renameUserOutput"
transport "http"
merge "user"
}
function "update_profile" {
camel "updateProfile"
has-input #true
input "updateProfileInput"
output "updateProfileOutput"
transport "http"
affects "user"
}
function "user_orders" {
camel "userOrders"
has-input #true
input "userOrdersInput"
output "userOrdersOutput"
transport "http"
context "user"
}
function "user_profile" {
camel "userProfile"
has-input #true
input "userProfileInput"
output "userProfileOutput"
transport "http"
context "user"
}
function "whoami" {
camel "whoami"
has-input #false
output "whoamiOutput"
transport "http"
}
context "user" {
function "user_orders"
function "user_profile"
param "user_id" {
type "integer"
required #true
shared-by "user_orders"
shared-by "user_profile"
}
}