rythazhur/mizan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

A channel's message slots are named from the client, on every backend

Browse Source 
The IR called them react-message and django-message, so a FastAPI channel had
to declare a DjangoMessage. They are client-message and server-message now,
and the direction words hold wherever a channel is declared: Params /
ClientMessage / ServerMessage, with mizan-core deriving <Pascal>Params and
friends so no backend names a type itself. Django's ReactChannel and
FastAPI's ReactChannel are both Channel.

mizan-fastapi never registered a channels extension, so build_ir() emitted no
channel at all and every payload type was invisible to codegen. It registers
one now. RegistryExtension is an ABC requiring all(), which is what the IR
reads — an extension that cannot enumerate its registrations no longer exists.

The gate that should have caught the rename could not: tests/afi registered no
channel because mizan-rust had no channel registry to register one in, so a
five-package rename of the wire contract passed byte-parity without a channel
byte crossing it. mizan-rust grows ChannelSlotKind, a CHANNELS slice, a
#[mizan::channel] macro, and KDL emission whose wire_to_pascal matches Python's
split; the AFI fixture now carries a channel with every slot and one with a
single slot, so all three backends prove the contract byte for byte.

MizanChannel held three Option<String> beside three has_*() predicates and
unwrapped them with defaults; it holds an ordered slot vector, so an absent
slot is absent rather than defaulted. The channels target emitted a React
hooks file that a stage1-only consumer could not compile — react emits that
now. The codegen's parity tests byte-compared emitted source against baselines
without ever compiling it: they compile the generated crate and run its tests,
import the generated Python package and call every method, and typecheck each
TypeScript target against a consumer.

Also fixed at source: app_visitor printed its import diagnostic to stdout, the
stream export_mizan_ir writes KDL to, so a failed import silently corrupted the
IR; the apps root was hardcoded to "apps"; _default_literal crashed build_ir on
any non-JSON-serializable field default; Django and mizan-core derived Pascal
names two different ways, disagreeing on every dotted channel name.

ir.py builds a document and renders templates/ir/document.kdl.j2 rather than
appending KDL strings with hand-tracked indentation, and named types resolve to
a fixed point — a model reachable only through a union branch was referenced by
a ref that no type block ever defined.

The rest is the write-gate's own classifiers run over the standing tree:
relative imports, silent swallows, Protocol contracts that should be ABCs,
emitters hand-rendering target source, catch-all arms over closed enums, and
comments narrating the project rather than the code.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ryth Azhur
2026-07-27 14:03:19 -04:00
parent 398c90fc8b
commit 3aafec6dd4
345 changed files with 11054 additions and 17359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
protocol/mizan-codegen/tests/channels_smoke.rs
View File

@@ -1,80 +0,0 @@
//! Smoke test for the channels target against a synthetic fixture.
//! The JS channels.mjs runs types through `openapi-typescript` which the
//! Rust codegen replaces with direct interface emission; byte-equivalence
//! against the JS baseline is intentionally not the gate. Instead this
//! test checks structural properties of the emitted output.
use std::collections::BTreeMap;
use std::path::PathBuf;
use mizan_codegen::config::{Config, SourceConfig};
use mizan_codegen::emit::CodegenTarget;
use mizan_codegen::emit::channels::ChannelsTarget;
use mizan_codegen::fetch::parse_ir_from_str;
fn fixture_config() -> Config {
Config {
project_id: None,
output: PathBuf::from("/tmp"),
targets: vec!["channels".to_string()],
source: SourceConfig { fastapi: None, django: None, rust: None, script: None },
rust_kernel: None,
rust_crate_name: None,
}
}
#[test]
fn channels_target_emits_expected_files() {
let raw = std::fs::read_to_string(
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/channels_ir.kdl"),
).unwrap();
let ir = parse_ir_from_str(&raw).unwrap();
let files = ChannelsTarget.emit(&ir, &fixture_config());
assert_eq!(files.len(), 2, "channels target emits 2 files when channels present");
let by_path: BTreeMap<PathBuf, &str> =
files.iter().map(|f| (f.rel_path.clone(), f.content.as_str())).collect();
let ts = by_path.get(&PathBuf::from("channels.ts"))
.expect("channels.ts emitted");
for expected in [
"export interface ChatChannelParams",
"export interface ChatReactMessage",
"export interface ChatDjangoMessage",
"export interface NotificationsDjangoMessage",
"export const CHANNELS = {",
"chat: {",
"notifications: {",
"hasParams: true",
"hasParams: false",
] {
assert!(ts.contains(expected), "channels.ts must contain {expected:?}");
}
let hooks = by_path.get(&PathBuf::from("channels.hooks.tsx"))
.expect("channels.hooks.tsx emitted");
for expected in [
"import { useChannel, type ChannelSubscription } from 'mizan/channels'",
"export function useChatChannel(params: ChatChannelParams)",
"export function useNotificationsChannel()",
"ChannelSubscription<ChatChannelParams, ChatDjangoMessage, ChatReactMessage>",
"ChannelSubscription<Record<string, never>, NotificationsDjangoMessage, never>",
] {
assert!(hooks.contains(expected), "channels.hooks.tsx must contain {expected:?}");
}
}
#[test]
fn channels_target_emits_nothing_when_empty() {
// AFI fixture has no channels — target should produce zero files.
let raw = std::fs::read_to_string(
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/afi_ir.kdl"),
).unwrap();
let ir = parse_ir_from_str(&raw).unwrap();
let files = ChannelsTarget.emit(&ir, &fixture_config());
assert!(files.is_empty(), "no channels → no files");
}

4
protocol/mizan-codegen/tests/fixtures/baselines/python/__init__.py vendored
View File

@@ -1,4 +0,0 @@
# AUTO-GENERATED by mizan — do not edit
from .client import MizanClient # noqa: F401
from .types import * # noqa: F401, F403

67
protocol/mizan-codegen/tests/fixtures/baselines/python/client.py vendored
View File

@@ -1,67 +0,0 @@
# AUTO-GENERATED by mizan — do not edit
from __future__ import annotations
from collections.abc import Callable
from typing import Any
# Built from frontends/mizan-rust with `maturin develop --features pyo3`.
from mizan_rust import PyMizanClient, PyContextSubscription
from .types import * # noqa: F401, F403
from .types import BaseModel # re-import for the synthesized ContextData classes
class MizanClient:
"""Typed Python facade over the PyO3 mizan-rust kernel."""
def __init__(self, base_url: str, *, session: bool = False,
csrf_cookie_name: str = "csrftoken",
csrf_header_name: str = "X-CSRFToken") -> None:
self._inner = PyMizanClient(
base_url,
session=session,
csrf_cookie_name=csrf_cookie_name,
csrf_header_name=csrf_header_name,
)
def fetch_user_context(self, user_id: int) -> "UserContextData":
raw = self._inner.fetch_context("user", {"user_id": user_id})
return UserContextData(**raw)
def subscribe_user_context(self, user_id: int,
callback: Callable[[dict[str, Any]], None]) -> PyContextSubscription:
return self._inner.subscribe_context("user", {"user_id": user_id}, callback)
def call_echo(self, args: EchoInput) -> EchoOutput:
raw = self._inner.call("echo", args.model_dump())
return EchoOutput(**raw)
def call_find_user(self, args: FindUserInput) -> FindUserOutput | None:
raw = self._inner.call("find_user", args.model_dump())
return FindUserOutput(**raw) if raw is not None else None
def call_rename_user(self, args: RenameUserInput) -> RenameUserOutput:
raw = self._inner.call("rename_user", args.model_dump())
return RenameUserOutput(**raw)
def call_update_profile(self, args: UpdateProfileInput) -> UpdateProfileOutput:
raw = self._inner.call("update_profile", args.model_dump())
return UpdateProfileOutput(**raw)
def call_whoami(self) -> WhoamiOutput:
raw = self._inner.call("whoami", {})
return WhoamiOutput(**raw)
def invalidate(self, context: str) -> None:
self._inner.invalidate(context)
def invalidate_scoped(self, context: str, params: dict[str, Any]) -> None:
self._inner.invalidate_scoped(context, params)
# ── Context data shapes (per-context bundle) ──────────────────────────────
class UserContextData(BaseModel):
"""Bundled return of fetch_user_context."""
user_orders: UserOrdersOutput
user_profile: UserProfileOutput

56
protocol/mizan-codegen/tests/fixtures/baselines/python/types.py vendored
View File

@@ -1,56 +0,0 @@
# AUTO-GENERATED by mizan — do not edit
from __future__ import annotations
from typing import Any, Literal
from pydantic import BaseModel
class OrderOutput(BaseModel):
id: int
user_id: int
total: int
class EchoInput(BaseModel):
text: str
class EchoOutput(BaseModel):
message: str
class FindUserInput(BaseModel):
user_id: int
class FindUserOutput(BaseModel):
user_id: int
name: str
class RenameUserInput(BaseModel):
user_id: int
name: str
class RenameUserOutput(BaseModel):
user_id: int
name: str
class UpdateProfileInput(BaseModel):
user_id: int
name: str
class UpdateProfileOutput(BaseModel):
ok: bool
class UserOrdersInput(BaseModel):
user_id: int
UserOrdersOutput = list[OrderOutput]
class UserProfileInput(BaseModel):
user_id: int
class UserProfileOutput(BaseModel):
user_id: int
name: str
class WhoamiOutput(BaseModel):
email: str
authenticated: bool

18
protocol/mizan-codegen/tests/fixtures/baselines/react/contexts/user.ts vendored
View File

@@ -1,18 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanFetch } from '@mizan/base'
import type { userOrdersOutput, userProfileOutput } from '../types'
export interface UserContextData {
user_orders: userOrdersOutput
user_profile: userProfileOutput
}
export interface UserContextParams {
user_id: number
}
export function fetchUserContext(params: UserContextParams): Promise<UserContextData> {
return mizanFetch('user', params)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/react/functions/echo.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { echoInput, echoOutput } from '../types'
export function callEcho(args: echoInput): Promise<echoOutput> {
return mizanCall('echo', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/react/functions/findUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { findUserInput, findUserOutput } from '../types'
export function callFindUser(args: findUserInput): Promise<findUserOutput> {
return mizanCall('find_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/react/functions/renameUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { renameUserInput, renameUserOutput } from '../types'
export function callRenameUser(args: renameUserInput): Promise<renameUserOutput> {
return mizanCall('rename_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/react/functions/whoami.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { whoamiOutput } from '../types'
export function callWhoami(): Promise<whoamiOutput> {
return mizanCall('whoami', {})
}

14
protocol/mizan-codegen/tests/fixtures/baselines/react/index.ts vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export * from './types'
export { fetchUserContext, type UserContextData, type UserContextParams } from './contexts/user'
export { callEcho } from './functions/echo'
export { callFindUser } from './functions/findUser'
export { callRenameUser } from './functions/renameUser'
export { callUpdateProfile } from './mutations/updateProfile'
export { callWhoami } from './functions/whoami'
// Stage 2 framework adapter
export * from './react'

9
protocol/mizan-codegen/tests/fixtures/baselines/react/mutations/updateProfile.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { updateProfileInput, updateProfileOutput } from '../types'
export function callUpdateProfile(args: updateProfileInput): Promise<updateProfileOutput> {
return mizanCall('update_profile', args)
}

156
protocol/mizan-codegen/tests/fixtures/baselines/react/react.tsx vendored
View File

@@ -1,156 +0,0 @@
'use client'
// AUTO-GENERATED by mizan — do not edit
import {
createContext,
useCallback,
useContext,
useEffect,
useRef,
useState,
useSyncExternalStore,
type ReactNode,
} from 'react'
import {
configure,
mizanCall,
mizanFetch,
registerContext,
type ContextState,
} from '@mizan/base'
import { fetchUserContext, type UserContextData, type UserContextParams, callUpdateProfile, callEcho, callFindUser, callRenameUser, callWhoami, type userOrdersOutput, type userProfileOutput } from './index'
// Internal — runs inside a Provider, registers with the kernel exactly once.
function useContextSubscription<T>(
name: string,
params: Record<string, any>,
fetchFn: () => Promise<T>,
initialData?: T,
): ContextState<T> {
const ref = useRef<ReturnType<typeof registerContext> | null>(null)
if (!ref.current) {
ref.current = registerContext(name, params, fetchFn, initialData)
}
const handle = ref.current
useEffect(() => {
if (handle.getState().status === 'idle') handle.refetch()
return () => handle.unregister()
}, [handle])
return useSyncExternalStore(handle.subscribe, handle.getState, handle.getState)
}
// Internal — wraps an imperative call() with isPending / error state.
interface MutationHook<TArgs, TResult> {
mutate: (args: TArgs) => Promise<TResult>
isPending: boolean
error: Error | null
}
function useMutation<TArgs, TResult>(
callFn: (args: TArgs) => Promise<TResult>,
): MutationHook<TArgs, TResult> {
const [isPending, setIsPending] = useState(false)
const [error, setError] = useState<Error | null>(null)
const mutate = useCallback(async (args: TArgs) => {
setIsPending(true)
setError(null)
try {
return await callFn(args)
} catch (e) {
setError(e as Error)
throw e
} finally {
setIsPending(false)
}
}, [callFn])
return { mutate, isPending, error }
}
// ── User Context ──
const UserCtx = createContext<ContextState<UserContextData> | null>(null)
export function UserContext({ children, ...params }: UserContextParams & { children: ReactNode }) {
const state = useContextSubscription('user', params, () => fetchUserContext(params))
return <UserCtx.Provider value={state}>{children}</UserCtx.Provider>
}
export function useUserContext(): ContextState<UserContextData> {
const ctx = useContext(UserCtx)
if (!ctx) throw new Error('useUserContext requires <UserContext>')
return ctx
}
export function useUserOrders(): userOrdersOutput | null {
return useUserContext().data?.user_orders ?? null
}
export function useUserProfile(): userProfileOutput | null {
return useUserContext().data?.user_profile ?? null
}
export function useUpdateProfile() {
return useMutation<Parameters<typeof callUpdateProfile>[0], Awaited<ReturnType<typeof callUpdateProfile>>>(callUpdateProfile)
}
export function useEcho() {
return useMutation<Parameters<typeof callEcho>[0], Awaited<ReturnType<typeof callEcho>>>(callEcho)
}
export function useFindUser() {
return useMutation<Parameters<typeof callFindUser>[0], Awaited<ReturnType<typeof callFindUser>>>(callFindUser)
}
export function useRenameUser() {
return useMutation<Parameters<typeof callRenameUser>[0], Awaited<ReturnType<typeof callRenameUser>>>(callRenameUser)
}
export function useWhoami() {
return useMutation<void, Awaited<ReturnType<typeof callWhoami>>>(() => callWhoami() as any)
}
// ── MizanContext root provider ──
export interface MizanContextProps {
/** Base URL for protocol endpoints. Defaults to "/api/mizan". */
baseUrl?: string
/** Set to `false` for backends without a `/session/` endpoint (e.g. FastAPI). */
session?: boolean
children: ReactNode
}
/**
* Root provider — calls configure() once and mounts the global context (if defined).
* Must wrap any component using Mizan-generated hooks.
*/
export function MizanContext({ baseUrl, session, children }: MizanContextProps) {
const configured = useRef(false)
if (!configured.current) {
const opts: Parameters<typeof configure>[0] = {}
if (baseUrl !== undefined) opts.baseUrl = baseUrl
if (session !== undefined) opts.session = session
if (Object.keys(opts).length > 0) configure(opts)
configured.current = true
}
return <>{children}</>
}
// ── Imperative escape hatch ──
/**
* Returns the imperative kernel API. For test harnesses or rare cases where
* a typed generated hook does not fit. Most app code should use the typed hooks.
*/
export function useMizan() {
return { call: mizanCall, fetch: mizanFetch }
}
export type { ContextState } from '@mizan/base'
export { configure, initSession, MizanError } from '@mizan/base'

64
protocol/mizan-codegen/tests/fixtures/baselines/react/types.ts vendored
View File

@@ -1,64 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export interface OrderOutput {
id: number
user_id: number
total: number
}
export interface echoInput {
text: string
}
export interface echoOutput {
message: string
}
export interface findUserInput {
user_id: number
}
export interface findUserOutput {
user_id: number
name: string
}
export interface renameUserInput {
user_id: number
name: string
}
export interface renameUserOutput {
user_id: number
name: string
}
export interface updateProfileInput {
user_id: number
name: string
}
export interface updateProfileOutput {
ok: boolean
}
export interface userOrdersInput {
user_id: number
}
export type userOrdersOutput = OrderOutput[]
export interface userProfileInput {
user_id: number
}
export interface userProfileOutput {
user_id: number
name: string
}
export interface whoamiOutput {
email: string
authenticated: boolean
}

10
protocol/mizan-codegen/tests/fixtures/baselines/rust/Cargo.toml vendored
View File

@@ -1,10 +0,0 @@
[package]
name = "fixture_client"
version = "0.1.0"
edition = "2021"
[dependencies]
mizan-rust = { path = "../../../frontends/mizan-rust" }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["rt", "macros"] }

3
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/contexts/mod.rs vendored
View File

@@ -1,3 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
pub mod user;

29
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/contexts/user.rs vendored
View File

@@ -1,29 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
use serde::{Deserialize, Serialize};
use serde_json::Value;
use mizan_rust::{MizanClient, MizanError};
use crate::types::{UserOrdersOutput, UserProfileOutput};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserContextData {
pub user_orders: UserOrdersOutput,
pub user_profile: UserProfileOutput,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserContextParams {
pub user_id: i64,
}
pub async fn fetch_user_context(
client: &MizanClient,
params: &UserContextParams,
) -> Result<UserContextData, MizanError> {
let params_value = serde_json::to_value(params).unwrap_or(Value::Object(Default::default()));
let raw = client.fetch_context("user", &params_value).await?;
serde_json::from_value(raw)
.map_err(|e| MizanError::transport(format!("decode user context: {e}")))
}

14
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/functions/echo.rs vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
use serde_json::Value;
use mizan_rust::{MizanClient, MizanError};
use crate::types::{EchoOutput, EchoInput};
pub async fn call_echo(client: &MizanClient, args: &EchoInput) -> Result<EchoOutput, MizanError> {
let args_value = serde_json::to_value(args).unwrap_or(Value::Object(Default::default()));
let raw = client.call("echo", args_value).await?;
serde_json::from_value(raw)
.map_err(|e| MizanError::transport(format!("decode echo result: {e}")))
}

14
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/functions/find_user.rs vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
use serde_json::Value;
use mizan_rust::{MizanClient, MizanError};
use crate::types::{FindUserOutput, FindUserInput};
pub async fn call_find_user(client: &MizanClient, args: &FindUserInput) -> Result<Option<FindUserOutput>, MizanError> {
let args_value = serde_json::to_value(args).unwrap_or(Value::Object(Default::default()));
let raw = client.call("find_user", args_value).await?;
serde_json::from_value(raw)
.map_err(|e| MizanError::transport(format!("decode find_user result: {e}")))
}

6
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/functions/mod.rs vendored
View File

@@ -1,6 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
pub mod echo;
pub mod find_user;
pub mod rename_user;
pub mod whoami;

14
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/functions/rename_user.rs vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
use serde_json::Value;
use mizan_rust::{MizanClient, MizanError};
use crate::types::{RenameUserOutput, RenameUserInput};
pub async fn call_rename_user(client: &MizanClient, args: &RenameUserInput) -> Result<RenameUserOutput, MizanError> {
let args_value = serde_json::to_value(args).unwrap_or(Value::Object(Default::default()));
let raw = client.call("rename_user", args_value).await?;
serde_json::from_value(raw)
.map_err(|e| MizanError::transport(format!("decode rename_user result: {e}")))
}

14
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/functions/whoami.rs vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
use serde_json::Value;
use mizan_rust::{MizanClient, MizanError};
use crate::types::{WhoamiOutput};
pub async fn call_whoami(client: &MizanClient) -> Result<WhoamiOutput, MizanError> {
let args_value = Value::Object(Default::default());
let raw = client.call("whoami", args_value).await?;
serde_json::from_value(raw)
.map_err(|e| MizanError::transport(format!("decode whoami result: {e}")))
}

8
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/lib.rs vendored
View File

@@ -1,8 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
pub mod types;
pub mod contexts;
pub mod mutations;
pub mod functions;
pub use mizan_rust::{MizanClient, MizanConfig, MizanError};

3
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/mutations/mod.rs vendored
View File

@@ -1,3 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
pub mod update_profile;

14
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/mutations/update_profile.rs vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
use serde_json::Value;
use mizan_rust::{MizanClient, MizanError};
use crate::types::{UpdateProfileOutput, UpdateProfileInput};
pub async fn call_update_profile(client: &MizanClient, args: &UpdateProfileInput) -> Result<UpdateProfileOutput, MizanError> {
let args_value = serde_json::to_value(args).unwrap_or(Value::Object(Default::default()));
let raw = client.call("update_profile", args_value).await?;
serde_json::from_value(raw)
.map_err(|e| MizanError::transport(format!("decode update_profile result: {e}")))
}

81
protocol/mizan-codegen/tests/fixtures/baselines/rust/src/types.rs vendored
View File

@@ -1,81 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
#![allow(non_camel_case_types)]
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrderOutput {
pub id: i64,
pub user_id: i64,
pub total: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EchoInput {
pub text: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EchoOutput {
pub message: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FindUserInput {
pub user_id: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FindUserOutput {
pub user_id: i64,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenameUserInput {
pub user_id: i64,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenameUserOutput {
pub user_id: i64,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateProfileInput {
pub user_id: i64,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateProfileOutput {
pub ok: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserOrdersInput {
pub user_id: i64,
}
pub type UserOrdersOutput = Vec<OrderOutput>;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserProfileInput {
pub user_id: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserProfileOutput {
pub user_id: i64,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WhoamiOutput {
pub email: String,
pub authenticated: bool,
}

18
protocol/mizan-codegen/tests/fixtures/baselines/stage1/contexts/user.ts vendored
View File

@@ -1,18 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanFetch } from '@mizan/base'
import type { userOrdersOutput, userProfileOutput } from '../types'
export interface UserContextData {
user_orders: userOrdersOutput
user_profile: userProfileOutput
}
export interface UserContextParams {
user_id: number
}
export function fetchUserContext(params: UserContextParams): Promise<UserContextData> {
return mizanFetch('user', params)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/stage1/functions/echo.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { echoInput, echoOutput } from '../types'
export function callEcho(args: echoInput): Promise<echoOutput> {
return mizanCall('echo', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/stage1/functions/findUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { findUserInput, findUserOutput } from '../types'
export function callFindUser(args: findUserInput): Promise<findUserOutput> {
return mizanCall('find_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/stage1/functions/renameUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { renameUserInput, renameUserOutput } from '../types'
export function callRenameUser(args: renameUserInput): Promise<renameUserOutput> {
return mizanCall('rename_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/stage1/functions/whoami.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { whoamiOutput } from '../types'
export function callWhoami(): Promise<whoamiOutput> {
return mizanCall('whoami', {})
}

11
protocol/mizan-codegen/tests/fixtures/baselines/stage1/index.ts vendored
View File

@@ -1,11 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export * from './types'
export { fetchUserContext, type UserContextData, type UserContextParams } from './contexts/user'
export { callEcho } from './functions/echo'
export { callFindUser } from './functions/findUser'
export { callRenameUser } from './functions/renameUser'
export { callUpdateProfile } from './mutations/updateProfile'
export { callWhoami } from './functions/whoami'

9
protocol/mizan-codegen/tests/fixtures/baselines/stage1/mutations/updateProfile.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { updateProfileInput, updateProfileOutput } from '../types'
export function callUpdateProfile(args: updateProfileInput): Promise<updateProfileOutput> {
return mizanCall('update_profile', args)
}

64
protocol/mizan-codegen/tests/fixtures/baselines/stage1/types.ts vendored
View File

@@ -1,64 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export interface OrderOutput {
id: number
user_id: number
total: number
}
export interface echoInput {
text: string
}
export interface echoOutput {
message: string
}
export interface findUserInput {
user_id: number
}
export interface findUserOutput {
user_id: number
name: string
}
export interface renameUserInput {
user_id: number
name: string
}
export interface renameUserOutput {
user_id: number
name: string
}
export interface updateProfileInput {
user_id: number
name: string
}
export interface updateProfileOutput {
ok: boolean
}
export interface userOrdersInput {
user_id: number
}
export type userOrdersOutput = OrderOutput[]
export interface userProfileInput {
user_id: number
}
export interface userProfileOutput {
user_id: number
name: string
}
export interface whoamiOutput {
email: string
authenticated: boolean
}

18
protocol/mizan-codegen/tests/fixtures/baselines/svelte/contexts/user.ts vendored
View File

@@ -1,18 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanFetch } from '@mizan/base'
import type { userOrdersOutput, userProfileOutput } from '../types'
export interface UserContextData {
user_orders: userOrdersOutput
user_profile: userProfileOutput
}
export interface UserContextParams {
user_id: number
}
export function fetchUserContext(params: UserContextParams): Promise<UserContextData> {
return mizanFetch('user', params)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/svelte/functions/echo.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { echoInput, echoOutput } from '../types'
export function callEcho(args: echoInput): Promise<echoOutput> {
return mizanCall('echo', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/svelte/functions/findUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { findUserInput, findUserOutput } from '../types'
export function callFindUser(args: findUserInput): Promise<findUserOutput> {
return mizanCall('find_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/svelte/functions/renameUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { renameUserInput, renameUserOutput } from '../types'
export function callRenameUser(args: renameUserInput): Promise<renameUserOutput> {
return mizanCall('rename_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/svelte/functions/whoami.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { whoamiOutput } from '../types'
export function callWhoami(): Promise<whoamiOutput> {
return mizanCall('whoami', {})
}

14
protocol/mizan-codegen/tests/fixtures/baselines/svelte/index.ts vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export * from './types'
export { fetchUserContext, type UserContextData, type UserContextParams } from './contexts/user'
export { callEcho } from './functions/echo'
export { callFindUser } from './functions/findUser'
export { callRenameUser } from './functions/renameUser'
export { callUpdateProfile } from './mutations/updateProfile'
export { callWhoami } from './functions/whoami'
// Stage 2 framework adapter
export * from './svelte'

9
protocol/mizan-codegen/tests/fixtures/baselines/svelte/mutations/updateProfile.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { updateProfileInput, updateProfileOutput } from '../types'
export function callUpdateProfile(args: updateProfileInput): Promise<updateProfileOutput> {
return mizanCall('update_profile', args)
}

29
protocol/mizan-codegen/tests/fixtures/baselines/svelte/svelte.ts vendored
View File

@@ -1,29 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { readable, type Readable } from 'svelte/store'
import { registerContext, type ContextState } from '@mizan/base'
import { fetchUserContext, type UserContextData, type UserContextParams, callUpdateProfile, callEcho, callFindUser, callRenameUser, callWhoami } from '../index'
export function createUserContext(params: UserContextParams) {
const store = readable<ContextState<UserContextData>>(
{ data: null, status: 'idle', error: null },
(set) => {
const handle = registerContext('user', params, () => fetchUserContext(params))
const unsub = handle.subscribe(() => set(handle.getState()))
handle.refetch()
return () => { unsub(); handle.unregister() }
},
)
return store
}
export { callUpdateProfile } from '../index'
export { callEcho } from '../index'
export { callFindUser } from '../index'
export { callRenameUser } from '../index'
export { callWhoami } from '../index'
export type { ContextState } from '@mizan/base'
export { configure, initSession, MizanError } from '@mizan/base'

64
protocol/mizan-codegen/tests/fixtures/baselines/svelte/types.ts vendored
View File

@@ -1,64 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export interface OrderOutput {
id: number
user_id: number
total: number
}
export interface echoInput {
text: string
}
export interface echoOutput {
message: string
}
export interface findUserInput {
user_id: number
}
export interface findUserOutput {
user_id: number
name: string
}
export interface renameUserInput {
user_id: number
name: string
}
export interface renameUserOutput {
user_id: number
name: string
}
export interface updateProfileInput {
user_id: number
name: string
}
export interface updateProfileOutput {
ok: boolean
}
export interface userOrdersInput {
user_id: number
}
export type userOrdersOutput = OrderOutput[]
export interface userProfileInput {
user_id: number
}
export interface userProfileOutput {
user_id: number
name: string
}
export interface whoamiOutput {
email: string
authenticated: boolean
}

18
protocol/mizan-codegen/tests/fixtures/baselines/vue/contexts/user.ts vendored
View File

@@ -1,18 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanFetch } from '@mizan/base'
import type { userOrdersOutput, userProfileOutput } from '../types'
export interface UserContextData {
user_orders: userOrdersOutput
user_profile: userProfileOutput
}
export interface UserContextParams {
user_id: number
}
export function fetchUserContext(params: UserContextParams): Promise<UserContextData> {
return mizanFetch('user', params)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/vue/functions/echo.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { echoInput, echoOutput } from '../types'
export function callEcho(args: echoInput): Promise<echoOutput> {
return mizanCall('echo', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/vue/functions/findUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { findUserInput, findUserOutput } from '../types'
export function callFindUser(args: findUserInput): Promise<findUserOutput> {
return mizanCall('find_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/vue/functions/renameUser.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { renameUserInput, renameUserOutput } from '../types'
export function callRenameUser(args: renameUserInput): Promise<renameUserOutput> {
return mizanCall('rename_user', args)
}

9
protocol/mizan-codegen/tests/fixtures/baselines/vue/functions/whoami.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { whoamiOutput } from '../types'
export function callWhoami(): Promise<whoamiOutput> {
return mizanCall('whoami', {})
}

14
protocol/mizan-codegen/tests/fixtures/baselines/vue/index.ts vendored
View File

@@ -1,14 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export * from './types'
export { fetchUserContext, type UserContextData, type UserContextParams } from './contexts/user'
export { callEcho } from './functions/echo'
export { callFindUser } from './functions/findUser'
export { callRenameUser } from './functions/renameUser'
export { callUpdateProfile } from './mutations/updateProfile'
export { callWhoami } from './functions/whoami'
// Stage 2 framework adapter
export * from './vue'

9
protocol/mizan-codegen/tests/fixtures/baselines/vue/mutations/updateProfile.ts vendored
View File

@@ -1,9 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { mizanCall } from '@mizan/base'
import type { updateProfileInput, updateProfileOutput } from '../types'
export function callUpdateProfile(args: updateProfileInput): Promise<updateProfileOutput> {
return mizanCall('update_profile', args)
}

64
protocol/mizan-codegen/tests/fixtures/baselines/vue/types.ts vendored
View File

@@ -1,64 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
export interface OrderOutput {
id: number
user_id: number
total: number
}
export interface echoInput {
text: string
}
export interface echoOutput {
message: string
}
export interface findUserInput {
user_id: number
}
export interface findUserOutput {
user_id: number
name: string
}
export interface renameUserInput {
user_id: number
name: string
}
export interface renameUserOutput {
user_id: number
name: string
}
export interface updateProfileInput {
user_id: number
name: string
}
export interface updateProfileOutput {
ok: boolean
}
export interface userOrdersInput {
user_id: number
}
export type userOrdersOutput = OrderOutput[]
export interface userProfileInput {
user_id: number
}
export interface userProfileOutput {
user_id: number
name: string
}
export interface whoamiOutput {
email: string
authenticated: boolean
}

96
protocol/mizan-codegen/tests/fixtures/baselines/vue/vue.ts vendored
View File

@@ -1,96 +0,0 @@
// AUTO-GENERATED by mizan — do not edit
import { ref, computed, onMounted, onUnmounted, onServerPrefetch, type ComputedRef } from 'vue'
import { registerContext, type ContextState } from '@mizan/base'
import { fetchUserContext, type UserContextData, type UserContextParams, callUpdateProfile, callEcho, callFindUser, callRenameUser, callWhoami } from '../index'
export function useUserContext(params: UserContextParams) {
const state = ref<ContextState<UserContextData>>({ data: null, status: 'idle', error: null })
let handle: ReturnType<typeof registerContext> | null = null
onMounted(() => {
handle = registerContext('user', params, () => fetchUserContext(params))
handle.subscribe(() => { state.value = handle!.getState() })
handle.refetch()
})
onServerPrefetch(async () => {
handle = registerContext('user', params, () => fetchUserContext(params))
await handle.refetch()
state.value = handle.getState()
})
onUnmounted(() => { handle?.unregister() })
return {
state,
userOrders: computed(() => state.value.data?.user_orders ?? null) as ComputedRef<userOrdersOutput | null>,
userProfile: computed(() => state.value.data?.user_profile ?? null) as ComputedRef<userProfileOutput | null>,
loading: computed(() => state.value.status === 'loading'),
error: computed(() => state.value.error),
}
}
export function useUpdateProfile() {
const isPending = ref(false)
const error = ref<Error | null>(null)
async function mutate(args: Parameters<typeof callUpdateProfile>[0]) {
isPending.value = true; error.value = null
try { return await callUpdateProfile(args) }
catch (e) { error.value = e as Error; throw e }
finally { isPending.value = false }
}
return { mutate, isPending, error }
}
export function useEcho() {
const isPending = ref(false)
const error = ref<Error | null>(null)
async function mutate(args: Parameters<typeof callEcho>[0]) {
isPending.value = true; error.value = null
try { return await callEcho(args) }
catch (e) { error.value = e as Error; throw e }
finally { isPending.value = false }
}
return { mutate, isPending, error }
}
export function useFindUser() {
const isPending = ref(false)
const error = ref<Error | null>(null)
async function mutate(args: Parameters<typeof callFindUser>[0]) {
isPending.value = true; error.value = null
try { return await callFindUser(args) }
catch (e) { error.value = e as Error; throw e }
finally { isPending.value = false }
}
return { mutate, isPending, error }
}
export function useRenameUser() {
const isPending = ref(false)
const error = ref<Error | null>(null)
async function mutate(args: Parameters<typeof callRenameUser>[0]) {
isPending.value = true; error.value = null
try { return await callRenameUser(args) }
catch (e) { error.value = e as Error; throw e }
finally { isPending.value = false }
}
return { mutate, isPending, error }
}
export function useWhoami() {
const isPending = ref(false)
const error = ref<Error | null>(null)
async function mutate() {
isPending.value = true; error.value = null
try { return await callWhoami() }
catch (e) { error.value = e as Error; throw e }
finally { isPending.value = false }
}
return { mutate, isPending, error }
}
export type { ContextState } from '@mizan/base'
export { configure, initSession, MizanError } from '@mizan/base'

16
protocol/mizan-codegen/tests/fixtures/channels_ir.kdl vendored
View File

@@ -1,4 +1,4 @@
type "ChatChannelParams" {
type "ChatParams" {
struct {
field "room_id" {
primitive "string"
@@ -6,7 +6,7 @@ type "ChatChannelParams" {
}
}
type "ChatReactMessage" {
type "ChatClientMessage" {
struct {
field "text" {
primitive "string"
@@ -14,7 +14,7 @@ type "ChatReactMessage" {
}
}
type "ChatDjangoMessage" {
type "ChatServerMessage" {
struct {
field "text" {
primitive "string"
@@ -25,7 +25,7 @@ type "ChatDjangoMessage" {
}
}
type "NotificationsDjangoMessage" {
type "NotificationsServerMessage" {
struct {
field "body" {
primitive "string"
@@ -35,12 +35,12 @@ type "NotificationsDjangoMessage" {
channel "chat" {
pascal-name "Chat"
params "ChatChannelParams"
react-message "ChatReactMessage"
django-message "ChatDjangoMessage"
params "ChatParams"
client-message "ChatClientMessage"
server-message "ChatServerMessage"
}
channel "notifications" {
pascal-name "Notifications"
django-message "NotificationsDjangoMessage"
server-message "NotificationsServerMessage"
}

13
protocol/mizan-codegen/tests/fixtures/toolchain/channels-tsconfig.json vendored Normal file
View File

@@ -0,0 +1,13 @@
{
"compilerOptions": {
"strict": true,
"noEmit": true,
"target": "ES2020",
"module": "ESNext",
"moduleResolution": "Node",
"jsx": "preserve",
"skipLibCheck": true,
"types": []
},
"files": ["shims/mizan-channels.d.ts", "channels.ts", "channels.hooks.tsx"]
}

59
protocol/mizan-codegen/tests/fixtures/toolchain/drivers/react.tsx vendored Normal file
View File

@@ -0,0 +1,59 @@
import {
MizanContext,
UserContext,
useEcho,
useFindUser,
useMizan,
useRenameUser,
useUpdateProfile,
useUserContext,
useUserOrders,
useUserProfile,
useWhoami,
type ContextState,
} from '../src/react'
import type { UserContextData } from '../src/index'
export function Screen() {
return (
<MizanContext baseUrl="/api/mizan" session={false}>
<UserContext user_id={1}>
<Panel />
</UserContext>
</MizanContext>
)
}
function Panel() {
const context: ContextState<UserContextData> = useUserContext()
const orders = useUserOrders()
const profile = useUserProfile()
const echo = useEcho()
const findUser = useFindUser()
const renameUser = useRenameUser()
const updateProfile = useUpdateProfile()
const whoami = useWhoami()
const { call, fetch } = useMizan()
async function run() {
const echoed = await echo.mutate({ text: 'hello' })
const found = await findUser.mutate({ user_id: 1 })
const renamed = await renameUser.mutate({ user_id: 1, name: 'renamed' })
const updated = await updateProfile.mutate({ user_id: 1, name: 'renamed' })
const identity = await whoami.mutate()
const raw = await call('echo', { text: 'hello' })
const bundle = await fetch('user', { user_id: 1 })
console.log(echoed.message, found.name, renamed.name, updated.ok,
identity.authenticated, raw, bundle)
}
const pending: boolean = echo.isPending
const failure: Error | null = echo.error
return (
<button onClick={run} disabled={pending}>
{context.status} {orders?.length ?? 0} {profile?.name ?? ''} {failure?.message ?? ''}
</button>
)
}

58
protocol/mizan-codegen/tests/fixtures/toolchain/drivers/stage1.ts vendored Normal file
View File

@@ -0,0 +1,58 @@
import {
callEcho,
callFindUser,
callRenameUser,
callUpdateProfile,
callWhoami,
fetchUserContext,
type UserContextData,
type UserContextParams,
type echoInput,
type echoOutput,
type findUserInput,
type findUserOutput,
type renameUserInput,
type renameUserOutput,
type updateProfileInput,
type updateProfileOutput,
type userOrdersInput,
type userOrdersOutput,
type userProfileInput,
type userProfileOutput,
type whoamiOutput,
} from '../src/index'
export async function everyStage1EntryPoint(): Promise<void> {
const echoArgs: echoInput = { text: 'hello' }
const echoed: echoOutput = await callEcho(echoArgs)
const message: string = echoed.message
const whoami: whoamiOutput = await callWhoami()
const email: string = whoami.email
const authenticated: boolean = whoami.authenticated
const findArgs: findUserInput = { user_id: 1 }
const found: findUserOutput = await callFindUser(findArgs)
const foundName: string = found.name
const renameArgs: renameUserInput = { user_id: 1, name: 'renamed' }
const renamed: renameUserOutput = await callRenameUser(renameArgs)
const renamedId: number = renamed.user_id
const updateArgs: updateProfileInput = { user_id: 1, name: 'renamed' }
const updated: updateProfileOutput = await callUpdateProfile(updateArgs)
const ok: boolean = updated.ok
const params: UserContextParams = { user_id: 1 }
const bundle: UserContextData = await fetchUserContext(params)
const orders: userOrdersOutput = bundle.user_orders
const profile: userProfileOutput = bundle.user_profile
const ordersArgs: userOrdersInput = { user_id: 1 }
const profileArgs: userProfileInput = { user_id: 1 }
console.log(
message, email, authenticated, foundName, renamedId, ok,
orders.length, profile.name, ordersArgs.user_id, profileArgs.user_id,
)
}

28
protocol/mizan-codegen/tests/fixtures/toolchain/drivers/svelte.ts vendored Normal file
View File

@@ -0,0 +1,28 @@
import {
callEcho,
callFindUser,
callRenameUser,
callUpdateProfile,
callWhoami,
createUserContext,
type ContextState,
} from '../src/stores/svelte'
import type { UserContextData, UserContextParams } from '../src/index'
export async function everySvelteStoreEntryPoint(): Promise<void> {
const params: UserContextParams = { user_id: 1 }
const store = createUserContext(params)
const unsubscribe = store.subscribe((state: ContextState<UserContextData>) => {
console.log(state.status, state.data?.user_profile.name ?? '')
})
unsubscribe()
const echoed = await callEcho({ text: 'hello' })
const found = await callFindUser({ user_id: 1 })
const renamed = await callRenameUser({ user_id: 1, name: 'renamed' })
const updated = await callUpdateProfile({ user_id: 1, name: 'renamed' })
const identity = await callWhoami()
console.log(echoed.message, found.name, renamed.name, updated.ok, identity.authenticated)
}

32
protocol/mizan-codegen/tests/fixtures/toolchain/drivers/vue.ts vendored Normal file
View File

@@ -0,0 +1,32 @@
import {
useEcho,
useFindUser,
useRenameUser,
useUpdateProfile,
useUserContext,
useWhoami,
type ContextState,
} from '../src/composables/vue'
import type { UserContextData, UserContextParams } from '../src/index'
export async function everyVueComposable(): Promise<void> {
const params: UserContextParams = { user_id: 1 }
const user = useUserContext(params)
const state: ContextState<UserContextData> = user.state.value
const orders = user.userOrders.value
const profile = user.userProfile.value
const loading: boolean = user.loading.value
const failure: Error | null = user.error.value
const echoed = await useEcho().mutate({ text: 'hello' })
const found = await useFindUser().mutate({ user_id: 1 })
const renamed = await useRenameUser().mutate({ user_id: 1, name: 'renamed' })
const updated = await useUpdateProfile().mutate({ user_id: 1, name: 'renamed' })
const identity = await useWhoami().mutate()
console.log(
state.status, orders?.length ?? 0, profile?.name ?? '', loading, failure?.message ?? '',
echoed.message, found.name, renamed.name, updated.ok, identity.authenticated,
)
}

46
protocol/mizan-codegen/tests/fixtures/toolchain/mizan_rust.py vendored Normal file
View File

@@ -0,0 +1,46 @@
"""Import target for the generated client's `from mizan_rust import ...`.
The real module is a compiled PyO3 extension; this one records each call so the
driver can read the name and payload the generated method sent, and replies with
whatever `reply` currently holds.
"""
from typing import Any, Callable
class PyContextSubscription:
def __init__(self, name: str, params: dict[str, Any],
callback: Callable[[dict[str, Any]], None]) -> None:
self.name = name
self.params = params
self.callback = callback
class PyMizanClient:
def __init__(self, base_url: str, *, session: bool,
csrf_cookie_name: str, csrf_header_name: str) -> None:
self.base_url = base_url
self.session = session
self.csrf_cookie_name = csrf_cookie_name
self.csrf_header_name = csrf_header_name
self.calls: list[tuple[str, dict[str, Any]]] = []
self.invalidated: list[tuple[str, dict[str, Any] | None]] = []
self.reply: Any = None
def call(self, name: str, args: dict[str, Any]) -> Any:
self.calls.append((name, args))
return self.reply
def fetch_context(self, name: str, params: dict[str, Any]) -> Any:
self.calls.append((name, params))
return self.reply
def subscribe_context(self, name: str, params: dict[str, Any],
callback: Callable[[dict[str, Any]], None]) -> PyContextSubscription:
return PyContextSubscription(name, params, callback)
def invalidate(self, context: str) -> None:
self.invalidated.append((context, None))
def invalidate_scoped(self, context: str, params: dict[str, Any]) -> None:
self.invalidated.append((context, params))

73
protocol/mizan-codegen/tests/fixtures/toolchain/python_driver.py vendored Normal file
View File

@@ -0,0 +1,73 @@
"""Runs every generated client method against the recording kernel stub."""
from mizan_client import MizanClient
from mizan_client.client import UserContextData
from mizan_client.types import (
EchoInput,
EchoOutput,
FindUserInput,
FindUserOutput,
OrderOutput,
RenameUserInput,
RenameUserOutput,
UpdateProfileInput,
UpdateProfileOutput,
UserProfileOutput,
WhoamiOutput,
)
client = MizanClient("http://127.0.0.1:9/api/mizan")
kernel = client._inner
kernel.reply = {"message": "hi"}
echoed = client.call_echo(EchoInput(text="hello"))
assert isinstance(echoed, EchoOutput)
assert echoed.message == "hi"
assert kernel.calls[-1] == ("echo", {"text": "hello"})
kernel.reply = {"email": "ryth@example.com", "authenticated": True}
identity = client.call_whoami()
assert isinstance(identity, WhoamiOutput)
assert identity.authenticated is True
assert kernel.calls[-1] == ("whoami", {})
kernel.reply = {"user_id": 1, "name": "ryth"}
found = client.call_find_user(FindUserInput(user_id=1))
assert isinstance(found, FindUserOutput)
assert found.name == "ryth"
assert kernel.calls[-1] == ("find_user", {"user_id": 1})
kernel.reply = None
assert client.call_find_user(FindUserInput(user_id=2)) is None
kernel.reply = {"user_id": 1, "name": "renamed"}
renamed = client.call_rename_user(RenameUserInput(user_id=1, name="renamed"))
assert isinstance(renamed, RenameUserOutput)
assert renamed.name == "renamed"
kernel.reply = {"ok": True}
updated = client.call_update_profile(UpdateProfileInput(user_id=1, name="renamed"))
assert isinstance(updated, UpdateProfileOutput)
assert updated.ok is True
kernel.reply = {
"user_orders": [{"id": 7, "user_id": 1, "total": 42}],
"user_profile": {"user_id": 1, "name": "ryth"},
}
bundle = client.fetch_user_context(1)
assert isinstance(bundle, UserContextData)
assert isinstance(bundle.user_profile, UserProfileOutput)
assert isinstance(bundle.user_orders[0], OrderOutput)
assert bundle.user_orders[0].total == 42
assert kernel.calls[-1] == ("user", {"user_id": 1})
received: list[dict] = []
subscription = client.subscribe_user_context(1, received.append)
assert subscription.name == "user"
assert subscription.params == {"user_id": 1}
client.invalidate("user")
client.invalidate_scoped("user", {"user_id": 1})
assert kernel.invalidated == [("user", None), ("user", {"user_id": 1})]
print("generated python client exercised")

97
protocol/mizan-codegen/tests/fixtures/toolchain/rust_driver.rs vendored Normal file
View File

@@ -0,0 +1,97 @@
//! Consumer of the generated crate, compiled and run by `cargo test` inside
//! that crate. Every path, signature and re-export named here has to resolve
//! for the file to build at all.
use fixture_client::contexts::user::{fetch_user_context, UserContextData, UserContextParams};
use fixture_client::functions::echo::call_echo;
use fixture_client::functions::find_user::call_find_user;
use fixture_client::functions::rename_user::call_rename_user;
use fixture_client::functions::whoami::call_whoami;
use fixture_client::mutations::update_profile::call_update_profile;
use fixture_client::types::{
EchoInput, EchoOutput, FindUserInput, FindUserOutput, OrderOutput, RenameUserInput,
RenameUserOutput, UpdateProfileInput, UpdateProfileOutput, UserOrdersOutput,
UserProfileOutput, WhoamiOutput,
};
use fixture_client::{MizanClient, MizanConfig, MizanError};
async fn every_generated_entry_point(client: &MizanClient) -> Result<(), MizanError> {
let echoed: EchoOutput = call_echo(
client,
&EchoInput { text: "hello".to_string() },
).await?;
let identity: WhoamiOutput = call_whoami(client).await?;
let found: Option<FindUserOutput> = call_find_user(
client,
&FindUserInput { user_id: 1 },
).await?;
let renamed: RenameUserOutput = call_rename_user(
client,
&RenameUserInput { user_id: 1, name: "renamed".to_string() },
).await?;
let updated: UpdateProfileOutput = call_update_profile(
client,
&UpdateProfileInput { user_id: 1, name: "renamed".to_string() },
).await?;
let bundle: UserContextData = fetch_user_context(
client,
&UserContextParams { user_id: 1 },
).await?;
let orders: UserOrdersOutput = bundle.user_orders;
let profile: UserProfileOutput = bundle.user_profile;
println!(
"{} {} {} {} {} {} {}",
echoed.message,
identity.authenticated,
found.is_some(),
renamed.name,
updated.ok,
orders.len(),
profile.name,
);
Ok(())
}
#[test]
fn generated_entry_points_build_a_callable_future() {
let client = MizanClient::new(MizanConfig {
base_url: "http://127.0.0.1:9/api/mizan".to_string(),
session: false,
..MizanConfig::default()
});
drop(every_generated_entry_point(&client));
}
#[test]
fn generated_types_decode_the_wire_shape() {
let raw = r#"{
"user_orders": [{"id": 7, "user_id": 1, "total": 42}],
"user_profile": {"user_id": 1, "name": "ryth"}
}"#;
let bundle: UserContextData = serde_json::from_str(raw).expect("context bundle decodes");
assert_eq!(bundle.user_profile.user_id, 1);
assert_eq!(bundle.user_profile.name, "ryth");
assert_eq!(bundle.user_orders.len(), 1);
let order: &OrderOutput = &bundle.user_orders[0];
assert_eq!(order.id, 7);
assert_eq!(order.total, 42);
let echoed: EchoOutput =
serde_json::from_str(r#"{"message": "hi"}"#).expect("echo output decodes");
assert_eq!(echoed.message, "hi");
let encoded = serde_json::to_string(&EchoInput { text: "hi".to_string() })
.expect("echo input encodes");
assert_eq!(encoded, r#"{"text":"hi"}"#);
}

22
protocol/mizan-codegen/tests/fixtures/toolchain/shims/mizan-channels.d.ts vendored Normal file
View File

@@ -0,0 +1,22 @@
declare module 'mizan/channels' {
export interface ChannelSubscription<
TParams = unknown,
TServerMessage = unknown,
TClientMessage = unknown,
> {
status: 'connecting' | 'connected' | 'disconnected'
messages: TServerMessage[]
send: TClientMessage extends never ? never : (message: TClientMessage) => void
unsubscribe: () => void
clearMessages: () => void
}
export function useChannel<
TParams = undefined,
TServerMessage = unknown,
TClientMessage = unknown,
>(
channelName: string,
params?: TParams,
): ChannelSubscription<TParams, TServerMessage, TClientMessage>
}

13
protocol/mizan-codegen/tests/fixtures/toolchain/shims/svelte-store.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
declare module 'svelte/store' {
export type Subscriber<T> = (value: T) => void
export type Unsubscriber = () => void
export interface Readable<T> {
subscribe(run: Subscriber<T>): Unsubscriber
}
export function readable<T>(
value: T,
start?: (set: Subscriber<T>) => Unsubscriber | void,
): Readable<T>
}

15
protocol/mizan-codegen/tests/fixtures/toolchain/shims/vue.d.ts vendored Normal file
View File

@@ -0,0 +1,15 @@
declare module 'vue' {
export interface Ref<T> {
value: T
}
export interface ComputedRef<T> {
readonly value: T
}
export function ref<T>(value: T): Ref<T>
export function computed<T>(getter: () => T): ComputedRef<T>
export function onMounted(hook: () => void): void
export function onUnmounted(hook: () => void): void
export function onServerPrefetch(hook: () => void | Promise<void>): void
}

13
protocol/mizan-codegen/tests/fixtures/toolchain/tsconfig.json vendored Normal file
View File

@@ -0,0 +1,13 @@
{
"compilerOptions": {
"noEmit": true,
"strict": true,
"target": "ES2022",
"lib": ["ES2022", "DOM"],
"module": "ESNext",
"moduleResolution": "bundler",
"jsx": "react-jsx",
"skipLibCheck": true
},
"include": ["src/**/*", "shims/**/*", "drivers/**/*"]
}

125
protocol/mizan-codegen/tests/harness/mod.rs Normal file
View File

@@ -0,0 +1,125 @@
//! Plumbing shared by the per-target tests: emit a target onto a clean scratch
//! root, drop the consumer fixtures beside it, and run the language toolchain
//! over the result. A toolchain that cannot be located panics with the search
//! it performed rather than letting the test pass without checking anything.
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use mizan_codegen::config::Config;
use mizan_codegen::emit::EmittedFile;
use mizan_codegen::fetch::parse_ir_from_str;
use mizan_codegen::ir::MizanIR;
pub fn manifest_dir() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
}
pub fn load_ir(fixture: &str) -> MizanIR {
let path = manifest_dir().join("tests/fixtures").join(fixture);
let raw = fs::read_to_string(&path)
.unwrap_or_else(|e| panic!("read {}: {e}", path.display()));
parse_ir_from_str(&raw)
.unwrap_or_else(|e| panic!("parse {}: {e}", path.display()))
}
/// Emitters read the target list and write relative to `output`; the scratch
/// root is the process working directory for every toolchain run, so `.` is
/// the whole of the path configuration these tests need.
pub fn config_for(target: &str) -> Config {
Config {
output: PathBuf::from("."),
targets: vec![target.to_string()],
..Config::default()
}
}
/// Wipes and recreates `target/toolchain/<name>`. A failing run leaves its
/// sources there for inspection; the next run clears them.
pub fn scratch_root(name: &str) -> PathBuf {
let root = manifest_dir().join("target/toolchain").join(name);
if root.exists() {
fs::remove_dir_all(&root)
.unwrap_or_else(|e| panic!("clear {}: {e}", root.display()));
}
fs::create_dir_all(&root)
.unwrap_or_else(|e| panic!("create {}: {e}", root.display()));
root
}
pub fn write_emitted(root: &Path, files: &[EmittedFile]) {
assert!(!files.is_empty(), "target emitted no files");
for file in files {
write_file(&root.join(&file.rel_path), &file.content);
}
}
pub fn copy_fixture(rel: &str, dest: &Path) {
let src = manifest_dir().join("tests/fixtures/toolchain").join(rel);
let contents = fs::read_to_string(&src)
.unwrap_or_else(|e| panic!("read fixture {}: {e}", src.display()));
write_file(dest, &contents);
}
fn write_file(dest: &Path, contents: &str) {
let parent = match dest.parent() {
Some(dir) => dir,
None => Path::new("."),
};
fs::create_dir_all(parent)
.unwrap_or_else(|e| panic!("create {}: {e}", parent.display()));
fs::write(dest, contents)
.unwrap_or_else(|e| panic!("write {}: {e}", dest.display()));
}
pub fn resolve_on_path(program: &str) -> PathBuf {
let path_var = std::env::var("PATH")
.unwrap_or_else(|e| panic!("PATH must be readable to locate `{program}`: {e}"));
for dir in std::env::split_paths(&path_var) {
let candidate = dir.join(program);
if candidate.is_file() {
return candidate;
}
}
panic!(
"`{program}` is required to check the emitted client and is not on PATH:\n {path_var}"
);
}
pub fn run_tool(
program: &Path,
args: &[&str],
cwd: &Path,
env: &[(&str, &Path)],
what: &str,
) {
let mut command = Command::new(program);
command.args(args).current_dir(cwd);
for (key, value) in env {
command.env(key, value);
}
let output = command.output()
.unwrap_or_else(|e| panic!("spawn {}: {e}", program.display()));
if output.status.success() {
return;
}
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
panic!(
"{what} (exit {:?}); sources left at {}\n--- stdout ---\n{stdout}\n--- stderr ---\n{stderr}",
output.status.code(),
cwd.display(),
);
}

62
protocol/mizan-codegen/tests/ir_deserialization.rs
View File

@@ -1,15 +1,11 @@
//! IR deserialization tests against the AFI fixture (KDL).
//!
//! The fixture is captured from `cores/mizan-python/src/mizan_core/ir.py::build_ir()`
//! against `tests/afi/fixture.py`. Each test exercises a different facet
//! of the IR — function set, per-function field decoding, context-param
//! elevation, and named-type presence — to confirm the typed Rust structs
//! match the KDL shape the backend emits.
//! Decodes the AFI fixture into the typed IR structs. Each test reads back a
//! different facet of the KDL — the function set, per-function field decoding,
//! context-param elevation, and the named-type table.
use std::path::PathBuf;
use mizan_codegen::fetch::parse_ir_from_str;
use mizan_codegen::ir::{AffectKind, IsContext, NamedType, Primitive, Transport};
use mizan_codegen::ir::{AffectKind, CallInput, IsContext, Primitive, Transport};
fn load_fixture() -> mizan_codegen::ir::MizanIR {
@@ -43,15 +39,14 @@ fn afi_fixture_function_field_decode() {
let ir = load_fixture();
let echo = ir.functions.iter().find(|f| f.name == "echo").unwrap();
assert_eq!(echo.camel_name, "echo");
assert!(echo.has_input);
assert_eq!(echo.input_type.as_deref(), Some("echoInput"));
assert_eq!(echo.input, CallInput::Typed("echoInput".to_string()));
assert_eq!(echo.output_type, "echoOutput");
assert!(!echo.output_nullable);
assert_eq!(echo.transport, Transport::Http);
assert_eq!(echo.is_context, IsContext::No);
let whoami = ir.functions.iter().find(|f| f.name == "whoami").unwrap();
assert!(!whoami.has_input);
assert_eq!(whoami.input, CallInput::Absent);
// `find_user` returns `ProfileOutput | None` — outputNullable must be true.
let find_user = ir.functions.iter().find(|f| f.name == "find_user").unwrap();
@@ -73,6 +68,38 @@ fn afi_fixture_function_field_decode() {
}
/// `has-input` and `input` are two spellings of one fact; a document that
/// spells them against each other is rejected at the KDL crossing rather than
/// silently reaching a target as a no-argument call.
#[test]
fn contradictory_input_spellings_are_rejected() {
let declared_without_flag = r#"
function "echo" {
camel "echo"
has-input #false
input "echoInput"
output "echoOutput"
}
"#;
let err = parse_ir_from_str(declared_without_flag)
.expect_err("`input` with `has-input #false` must not parse")
.to_string();
assert!(err.contains("echoInput"), "fault must name the declared input type: {err}");
let flag_without_type = r#"
function "echo" {
camel "echo"
has-input #true
output "echoOutput"
}
"#;
let err = parse_ir_from_str(flag_without_type)
.expect_err("`has-input #true` with no `input` must not parse")
.to_string();
assert!(err.contains("has-input"), "fault must name `has-input`: {err}");
}
#[test]
fn afi_fixture_context_param_elevation() {
let ir = load_fixture();
@@ -90,9 +117,8 @@ fn afi_fixture_context_param_elevation() {
#[test]
fn afi_fixture_named_types_present() {
let ir = load_fixture();
// Every IR function references its <camelName>Input / <camelName>Output
// type by name; the IR's `type` section must declare each as a named
// type (struct, alias to a list, etc.).
// Every function names its `<camelName>Input` / `<camelName>Output` type,
// so the IR's type table must declare each one.
for expected in [
"echoInput", "echoOutput",
"whoamiOutput",
@@ -102,12 +128,6 @@ fn afi_fixture_named_types_present() {
"findUserInput", "findUserOutput",
"renameUserInput", "renameUserOutput",
] {
let ty = ir.types.get(expected)
.unwrap_or_else(|| panic!("missing type {expected:?}"));
// Each named type is one of the four KDL shapes — sanity-check
// we round-tripped a non-trivial declaration.
match ty {
NamedType::Struct(_) | NamedType::List(_) | NamedType::Enum(_) | NamedType::Alias(_) => {}
}
assert!(ir.types.contains_key(expected), "missing type {expected:?}");
}
}

75
protocol/mizan-codegen/tests/python_parity.rs
View File

@@ -1,75 +0,0 @@
//! Byte-equivalence test for the Python target against the JS baseline.
use std::collections::BTreeMap;
use std::path::PathBuf;
use mizan_codegen::config::{Config, SourceConfig};
use mizan_codegen::emit::{CodegenTarget, EmittedFile};
use mizan_codegen::emit::python::PythonClient;
use mizan_codegen::fetch::parse_ir_from_str;
fn load_ir() -> mizan_codegen::ir::MizanIR {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/afi_ir.kdl");
parse_ir_from_str(&std::fs::read_to_string(&path).unwrap()).unwrap()
}
fn fixture_config() -> Config {
Config {
project_id: None,
output: PathBuf::from("/tmp"),
targets: vec!["python".to_string()],
source: SourceConfig { fastapi: None, django: None, rust: None, script: None },
rust_kernel: None,
rust_crate_name: None,
}
}
fn read_baseline(rel: &str) -> String {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/baselines/python")
.join(rel);
std::fs::read_to_string(&path)
.unwrap_or_else(|e| panic!("read baseline {}: {e}", path.display()))
}
fn emit_index(files: &[EmittedFile]) -> BTreeMap<PathBuf, &str> {
files.iter().map(|f| (f.rel_path.clone(), f.content.as_str())).collect()
}
fn assert_byte_equal(rel: &str, files: &BTreeMap<PathBuf, &str>) {
let actual = files
.get(&PathBuf::from(rel))
.unwrap_or_else(|| panic!("Python target did not produce {rel}"));
let expected = read_baseline(rel);
if *actual != expected {
for (lineno, (a, b)) in actual.lines().zip(expected.lines()).enumerate() {
if a != b {
panic!(
"{rel} diverges at line {}:\n expected: {b:?}\n actual: {a:?}",
lineno + 1,
);
}
}
panic!(
"{rel} diverges in length: actual={} expected={}",
actual.len(), expected.len(),
);
}
}
#[test]
fn python_target_all_files_match_baseline() {
let ir = load_ir();
let files = PythonClient.emit(&ir, &fixture_config());
let index = emit_index(&files);
for rel in ["types.py", "client.py", "__init__.py"] {
assert_byte_equal(rel, &index);
}
}

31
protocol/mizan-codegen/tests/python_target.rs Normal file
View File

@@ -0,0 +1,31 @@
//! Emits the Python client as an importable package, drops a recording stand-in
//! for the PyO3 kernel beside it, and runs a consumer script under CPython. The
//! consumer imports the package, calls every generated method and reads the
//! Pydantic models back, so the emitted module has to import and execute.
mod harness;
use mizan_codegen::emit::CodegenTarget;
use mizan_codegen::emit::python::PythonClient;
#[test]
fn generated_package_imports_and_every_method_runs() {
let root = harness::scratch_root("python");
let ir = harness::load_ir("afi_ir.kdl");
harness::write_emitted(
&root.join("mizan_client"),
&PythonClient.emit(&ir, &harness::config_for("python")),
);
harness::copy_fixture("mizan_rust.py", &root.join("mizan_rust.py"));
harness::copy_fixture("python_driver.py", &root.join("driver.py"));
let uv = harness::resolve_on_path("uv");
harness::run_tool(
&uv,
&["run", "--no-project", "--with", "pydantic", "python", "driver.py"],
&root,
&[],
"the emitted Python client does not import or its consumer run fails",
);
}

54
protocol/mizan-codegen/tests/react_parity.rs
View File

@@ -1,54 +0,0 @@
//! Byte-equivalence test for the React target against the JS baseline.
use std::path::PathBuf;
use mizan_codegen::config::{Config, SourceConfig};
use mizan_codegen::emit::CodegenTarget;
use mizan_codegen::emit::react::ReactAdapter;
use mizan_codegen::fetch::parse_ir_from_str;
fn load_ir() -> mizan_codegen::ir::MizanIR {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/afi_ir.kdl");
parse_ir_from_str(&std::fs::read_to_string(&path).unwrap()).unwrap()
}
fn fixture_config() -> Config {
Config {
project_id: None,
output: PathBuf::from("/tmp"),
targets: vec!["react".to_string()],
source: SourceConfig { fastapi: None, django: None, rust: None, script: None },
rust_kernel: None,
rust_crate_name: None,
}
}
#[test]
fn react_target_byte_match() {
let ir = load_ir();
let files = ReactAdapter.emit(&ir, &fixture_config());
assert_eq!(files.len(), 1);
let actual = &files[0].content;
let expected_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/baselines/react/react.tsx");
let expected = std::fs::read_to_string(&expected_path).unwrap();
if *actual != expected {
for (lineno, (a, b)) in actual.lines().zip(expected.lines()).enumerate() {
if a != b {
panic!(
"react.tsx diverges at line {}:\n expected: {b:?}\n actual: {a:?}",
lineno + 1,
);
}
}
panic!(
"react.tsx diverges in length: actual={} expected={}",
actual.len(), expected.len(),
);
}
}

96
protocol/mizan-codegen/tests/rust_parity.rs
View File

@@ -1,96 +0,0 @@
//! Byte-equivalence between the Rust target and the JS rust.mjs baseline
//! against the AFI fixture. The downstream forcing function is the wire-
//! parity drivers under `tests/rust/`; this test catches divergence
//! earlier in the cycle without needing to spin a FastAPI fixture up.
use std::collections::BTreeMap;
use std::path::PathBuf;
use mizan_codegen::config::{Config, RustKernelSpec, SourceConfig};
use mizan_codegen::emit::{CodegenTarget, EmittedFile};
use mizan_codegen::emit::rust::RustCrate;
use mizan_codegen::fetch::parse_ir_from_str;
fn load_ir() -> mizan_codegen::ir::MizanIR {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/afi_ir.kdl");
parse_ir_from_str(&std::fs::read_to_string(&path).unwrap()).unwrap()
}
fn fixture_config() -> Config {
Config {
project_id: None,
output: PathBuf::from("/tmp"),
targets: vec!["rust".to_string()],
source: SourceConfig { fastapi: None, django: None, rust: None, script: None },
rust_kernel: Some(RustKernelSpec::Path {
path: "../../../frontends/mizan-rust".to_string(),
}),
rust_crate_name: Some("fixture_client".to_string()),
}
}
fn read_baseline(rel: &str) -> String {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/baselines/rust")
.join(rel);
std::fs::read_to_string(&path)
.unwrap_or_else(|e| panic!("read baseline {}: {e}", path.display()))
}
fn emit_index(files: &[EmittedFile]) -> BTreeMap<PathBuf, &str> {
files.iter().map(|f| (f.rel_path.clone(), f.content.as_str())).collect()
}
fn assert_byte_equal(rel: &str, files: &BTreeMap<PathBuf, &str>) {
let actual = files
.get(&PathBuf::from(rel))
.unwrap_or_else(|| panic!("Rust target did not produce {rel}"));
let expected = read_baseline(rel);
if *actual != expected {
for (lineno, (a, b)) in actual.lines().zip(expected.lines()).enumerate() {
if a != b {
panic!(
"{rel} diverges at line {}:\n expected: {b:?}\n actual: {a:?}",
lineno + 1,
);
}
}
panic!(
"{rel} diverges in length: actual={} expected={}\n--- actual (last 200) ---\n{}\n--- expected (last 200) ---\n{}",
actual.len(), expected.len(),
&actual[actual.len().saturating_sub(200)..],
&expected[expected.len().saturating_sub(200)..],
);
}
}
#[test]
fn rust_target_all_files_match_baseline() {
let ir = load_ir();
let files = RustCrate.emit(&ir, &fixture_config());
let index = emit_index(&files);
for rel in [
"Cargo.toml",
"src/lib.rs",
"src/types.rs",
"src/contexts/user.rs",
"src/contexts/mod.rs",
"src/functions/echo.rs",
"src/functions/whoami.rs",
"src/functions/find_user.rs",
"src/functions/rename_user.rs",
"src/functions/mod.rs",
"src/mutations/update_profile.rs",
"src/mutations/mod.rs",
] {
assert_byte_equal(rel, &index);
}
}

53
protocol/mizan-codegen/tests/rust_target.rs Normal file
View File

@@ -0,0 +1,53 @@
//! Emits the Rust client crate, drops a consumer into its `tests/`, and runs
//! `cargo test` inside it. The consumer names every generated module path and
//! calls every generated function, so the emitted crate has to compile against
//! the real `mizan-rust` kernel before its serde round-trips are asserted.
mod harness;
use std::path::PathBuf;
use mizan_codegen::config::{Config, RustKernelSpec};
use mizan_codegen::emit::CodegenTarget;
use mizan_codegen::emit::rust::RustCrate;
fn crate_config() -> Config {
let kernel = harness::manifest_dir().join("../../frontends/mizan-rust");
assert!(
kernel.join("Cargo.toml").is_file(),
"the generated crate depends on the kernel at {}",
kernel.display(),
);
Config {
rust_kernel: Some(RustKernelSpec::Path { path: kernel.display().to_string() }),
rust_crate_name: "fixture_client".to_string(),
..harness::config_for("rust")
}
}
/// Build artifacts live outside the scratch root so a rerun reuses the
/// compiled kernel and its dependency tree instead of rebuilding them.
fn shared_target_dir() -> PathBuf {
harness::manifest_dir().join("target/toolchain-cargo")
}
#[test]
fn generated_crate_compiles_and_its_tests_pass() {
let root = harness::scratch_root("rust");
let ir = harness::load_ir("afi_ir.kdl");
harness::write_emitted(&root, &RustCrate.emit(&ir, &crate_config()));
harness::copy_fixture("rust_driver.rs", &root.join("tests/driver.rs"));
let cargo = harness::resolve_on_path("cargo");
let target_dir = shared_target_dir();
harness::run_tool(
&cargo,
&["test"],
&root,
&[("CARGO_TARGET_DIR", target_dir.as_path())],
"the emitted Rust client crate does not build or its consumer tests fail",
);
}

143
protocol/mizan-codegen/tests/stage1_parity.rs
View File

@@ -1,143 +0,0 @@
//! Byte-equivalence tests for the deterministic Stage 1 files (contexts,
//! mutations, functions, index). Baseline output captured from the JS
//! codegen at `protocol/mizan-generate/generator/lib/stage1.mjs` against
//! the AFI fixture schema (`tests/fixtures/afi_ir.kdl`).
//!
//! `types.ts` is NOT byte-checked here — the JS codegen routes type
//! emission through openapi-typescript while the Rust substrate emits
//! Pydantic schemas directly. Equivalence for types.ts is structural
//! (named exports present and importable), checked in a separate test.
use std::collections::BTreeMap;
use std::path::PathBuf;
use mizan_codegen::config::{Config, SourceConfig};
use mizan_codegen::emit::{CodegenTarget, EmittedFile};
use mizan_codegen::emit::stage1::Stage1;
use mizan_codegen::fetch::parse_ir_from_str;
fn load_ir() -> mizan_codegen::ir::MizanIR {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/afi_ir.kdl");
let raw = std::fs::read_to_string(&path).unwrap();
parse_ir_from_str(&raw).unwrap()
}
fn synthetic_config() -> Config {
Config {
project_id: None,
output: PathBuf::from("/tmp"),
targets: vec!["stage1".to_string()],
source: SourceConfig { fastapi: None, django: None, rust: None, script: None },
rust_kernel: None,
rust_crate_name: None,
}
}
fn emit_index(files: &[EmittedFile]) -> BTreeMap<PathBuf, &str> {
files.iter().map(|f| (f.rel_path.clone(), f.content.as_str())).collect()
}
fn read_baseline(rel: &str) -> String {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/baselines/stage1")
.join(rel);
std::fs::read_to_string(&path)
.unwrap_or_else(|e| panic!("read baseline {}: {e}", path.display()))
}
fn assert_byte_equal(rel: &str, files: &BTreeMap<PathBuf, &str>) {
let actual = files
.get(&PathBuf::from(rel))
.unwrap_or_else(|| panic!("emitter did not produce {rel}"));
let expected = read_baseline(rel);
if *actual != expected {
// Surface a diff-friendly failure message — first divergent line wins.
for (lineno, (a, b)) in actual.lines().zip(expected.lines()).enumerate() {
if a != b {
panic!(
"{rel} diverges at line {}:\n expected: {b:?}\n actual: {a:?}",
lineno + 1,
);
}
}
panic!(
"{rel} diverges in length: actual={} expected={}",
actual.len(), expected.len(),
);
}
}
#[test]
fn stage1_contexts_user_byte_match() {
let ir = load_ir();
let files = Stage1.emit(&ir, &synthetic_config());
let index = emit_index(&files);
assert_byte_equal("contexts/user.ts", &index);
}
#[test]
fn stage1_function_files_byte_match() {
let ir = load_ir();
let files = Stage1.emit(&ir, &synthetic_config());
let index = emit_index(&files);
for rel in ["functions/echo.ts", "functions/whoami.ts",
"functions/findUser.ts", "functions/renameUser.ts"] {
assert_byte_equal(rel, &index);
}
}
#[test]
fn stage1_mutation_files_byte_match() {
let ir = load_ir();
let files = Stage1.emit(&ir, &synthetic_config());
let index = emit_index(&files);
assert_byte_equal("mutations/updateProfile.ts", &index);
}
#[test]
fn stage1_index_byte_match() {
let ir = load_ir();
let files = Stage1.emit(&ir, &synthetic_config());
let index = emit_index(&files);
assert_byte_equal("index.ts", &index);
}
#[test]
fn stage1_types_exports_expected_names() {
let ir = load_ir();
let files = Stage1.emit(&ir, &synthetic_config());
let index = emit_index(&files);
let types = index
.get(&PathBuf::from("types.ts"))
.expect("types.ts must be emitted");
// Every Pydantic schema named in the IR must surface as a top-level
// exported type or interface so Stage 2 adapters can import by name.
for expected in [
"echoInput", "echoOutput",
"whoamiOutput",
"userProfileInput", "userProfileOutput",
"userOrdersInput",
"updateProfileInput", "updateProfileOutput",
"findUserInput", "findUserOutput",
"renameUserInput", "renameUserOutput",
] {
let needle_interface = format!("export interface {expected} ");
let needle_type = format!("export type {expected} =");
assert!(
types.contains(&needle_interface) || types.contains(&needle_type),
"types.ts must export {expected:?} (interface or type)",
);
}
}

215
protocol/mizan-codegen/tests/typescript_targets.rs Normal file
View File

@@ -0,0 +1,215 @@
//! Emits each TypeScript target beside a hand-written consumer and runs `tsc`
//! over both. The consumer names every export the target is expected to carry,
//! so a missing symbol, a changed signature or an unresolvable import is a
//! compile error rather than a byte diff nobody can act on.
//!
//! The stage 1 client and the framework adapters share one scratch project; the
//! channel modules get their own, because they resolve the `mizan/channels`
//! runtime through an ambient declaration instead of a package.
mod harness;
use std::fs;
use std::path::{Path, PathBuf};
use mizan_codegen::emit::CodegenTarget;
use mizan_codegen::emit::EmittedFile;
use mizan_codegen::emit::channels::ChannelsTarget;
use mizan_codegen::emit::react::ReactAdapter;
use mizan_codegen::emit::stage1::Stage1;
use mizan_codegen::emit::svelte::SvelteAdapter;
use mizan_codegen::emit::vue::VueAdapter;
fn installed_node_modules() -> PathBuf {
let dir = harness::manifest_dir().join("../../frontends/mizan-react/node_modules");
assert!(
dir.is_dir(),
"the TypeScript toolchain and React typings are expected at {} — \
run `npm install` under frontends/mizan-react",
dir.display(),
);
dir
}
fn resolve_tsc() -> PathBuf {
let vendored = harness::manifest_dir()
.join("../../frontends/mizan-react/node_modules/.bin/tsc");
if vendored.is_file() {
return vendored;
}
harness::resolve_on_path("tsc")
}
fn link(target: &Path, alias: &Path) {
std::os::unix::fs::symlink(target, alias).unwrap_or_else(|e| {
panic!("link {} -> {}: {e}", alias.display(), target.display())
});
}
/// Scratch project holding the stage 1 client under `src/`, with the packages
/// the emitted imports name resolvable from a local `node_modules/`. Every
/// framework adapter imports stage 1, so each adapter test starts here.
fn stage1_project(name: &str) -> PathBuf {
let root = harness::scratch_root(name);
let ir = harness::load_ir("afi_ir.kdl");
harness::write_emitted(
&root.join("src"),
&Stage1.emit(&ir, &harness::config_for("stage1")),
);
harness::copy_fixture("tsconfig.json", &root.join("tsconfig.json"));
let modules = root.join("node_modules");
let scope = modules.join("@mizan");
fs::create_dir_all(&scope)
.unwrap_or_else(|e| panic!("create {}: {e}", scope.display()));
let installed = installed_node_modules();
link(&harness::manifest_dir().join("../../frontends/mizan-base"), &scope.join("base"));
link(&installed.join("react"), &modules.join("react"));
link(&installed.join("@types"), &modules.join("@types"));
root
}
fn typecheck(root: &Path, what: &str) {
harness::run_tool(&resolve_tsc(), &["--project", "."], root, &[], what);
}
fn select(files: Vec<EmittedFile>, rel_path: &str) -> EmittedFile {
let emitted: Vec<String> = files.iter()
.map(|f| f.rel_path.display().to_string())
.collect();
files.into_iter()
.find(|f| f.rel_path == Path::new(rel_path))
.unwrap_or_else(|| panic!("{rel_path} was not emitted; got {emitted:?}"))
}
#[test]
fn stage1_client_typechecks_against_a_consumer() {
let root = stage1_project("stage1");
harness::copy_fixture("drivers/stage1.ts", &root.join("drivers/stage1.ts"));
typecheck(&root, "the emitted stage 1 client does not type-check");
}
#[test]
fn react_adapter_typechecks_against_a_consumer() {
let root = stage1_project("react");
let ir = harness::load_ir("afi_ir.kdl");
harness::write_emitted(
&root.join("src"),
&ReactAdapter.emit(&ir, &harness::config_for("react")),
);
harness::copy_fixture("drivers/react.tsx", &root.join("drivers/react.tsx"));
typecheck(&root, "the emitted React adapter does not type-check");
}
#[test]
fn vue_adapter_typechecks_against_a_consumer() {
let root = stage1_project("vue");
let ir = harness::load_ir("afi_ir.kdl");
harness::write_emitted(
&root.join("src/composables"),
&VueAdapter.emit(&ir, &harness::config_for("vue")),
);
harness::copy_fixture("shims/vue.d.ts", &root.join("shims/vue.d.ts"));
harness::copy_fixture("drivers/vue.ts", &root.join("drivers/vue.ts"));
typecheck(&root, "the emitted Vue adapter does not type-check");
}
#[test]
fn svelte_adapter_typechecks_against_a_consumer() {
let root = stage1_project("svelte");
let ir = harness::load_ir("afi_ir.kdl");
harness::write_emitted(
&root.join("src/stores"),
&SvelteAdapter.emit(&ir, &harness::config_for("svelte")),
);
harness::copy_fixture("shims/svelte-store.d.ts", &root.join("shims/svelte-store.d.ts"));
harness::copy_fixture("drivers/svelte.ts", &root.join("drivers/svelte.ts"));
typecheck(&root, "the emitted Svelte adapter does not type-check");
}
#[test]
fn channel_modules_typecheck_and_carry_the_declared_surface() {
let ir = harness::load_ir("channels_ir.kdl");
let config = harness::config_for("channels");
let channel_files = ChannelsTarget.emit(&ir, &config);
assert_eq!(channel_files.len(), 1, "the channels target emits channels.ts alone");
let modules = [
select(channel_files, "channels.ts"),
select(ReactAdapter.emit(&ir, &config), "channels.hooks.tsx"),
];
let root = harness::scratch_root("channels");
harness::write_emitted(&root, &modules);
harness::copy_fixture("shims/mizan-channels.d.ts", &root.join("shims/mizan-channels.d.ts"));
harness::copy_fixture("channels-tsconfig.json", &root.join("tsconfig.json"));
typecheck(&root, "the emitted channel modules do not type-check");
let [channels_ts, channels_hooks] = &modules;
let ts = channels_ts.content.as_str();
let hooks = channels_hooks.content.as_str();
for expected in [
"export interface ChatParams",
"export interface ChatClientMessage",
"export interface ChatServerMessage",
"export interface NotificationsServerMessage",
"export const CHANNELS = {",
"'chat': {",
"'notifications': {",
"paramsType: 'ChatParams'",
"clientMessageType: 'ChatClientMessage'",
"serverMessageType: 'ChatServerMessage'",
"serverMessageType: 'NotificationsServerMessage'",
] {
assert!(ts.contains(expected), "channels.ts must contain {expected:?}");
}
assert!(
!ts.contains("import"),
"channels.ts must import nothing so non-React consumers can compile it",
);
for expected in [
"import { useChannel, type ChannelSubscription } from 'mizan/channels'",
"import type { ChatParams, ChatClientMessage, ChatServerMessage, \
NotificationsServerMessage } from './channels'",
"export function useChatChannel(params: ChatParams)",
"export function useNotificationsChannel()",
"ChannelSubscription<ChatParams, ChatServerMessage, ChatClientMessage>",
"ChannelSubscription<Record<string, never>, NotificationsServerMessage, never>",
] {
assert!(hooks.contains(expected), "channels.hooks.tsx must contain {expected:?}");
}
}
#[test]
fn channel_targets_emit_nothing_when_ir_carries_no_channels() {
let ir = harness::load_ir("afi_ir.kdl");
let config = harness::config_for("channels");
assert!(
ChannelsTarget.emit(&ir, &config).is_empty(),
"no channels → no channels.ts",
);
assert!(
!ReactAdapter.emit(&ir, &config).iter()
.any(|f| f.rel_path == Path::new("channels.hooks.tsx")),
"no channels → no channels.hooks.tsx",
);
}

66
protocol/mizan-codegen/tests/vue_svelte_parity.rs
View File

@@ -1,66 +0,0 @@
//! Byte-equivalence tests for Vue + Svelte targets against JS baselines.
use std::path::PathBuf;
use mizan_codegen::config::{Config, SourceConfig};
use mizan_codegen::emit::CodegenTarget;
use mizan_codegen::emit::svelte::SvelteAdapter;
use mizan_codegen::emit::vue::VueAdapter;
use mizan_codegen::fetch::parse_ir_from_str;
fn load_ir() -> mizan_codegen::ir::MizanIR {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/afi_ir.kdl");
parse_ir_from_str(&std::fs::read_to_string(&path).unwrap()).unwrap()
}
fn fixture_config(target: &str) -> Config {
Config {
project_id: None,
output: PathBuf::from("/tmp"),
targets: vec![target.to_string()],
source: SourceConfig { fastapi: None, django: None, rust: None, script: None },
rust_kernel: None,
rust_crate_name: None,
}
}
fn assert_byte_equal(actual: &str, baseline_path: &str, label: &str) {
let baseline = std::fs::read_to_string(
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(baseline_path),
).unwrap();
if actual != baseline {
for (lineno, (a, b)) in actual.lines().zip(baseline.lines()).enumerate() {
if a != b {
panic!(
"{label} diverges at line {}:\n expected: {b:?}\n actual: {a:?}",
lineno + 1,
);
}
}
panic!(
"{label} diverges in length: actual={} expected={}",
actual.len(), baseline.len(),
);
}
}
#[test]
fn vue_target_byte_match() {
let ir = load_ir();
let files = VueAdapter.emit(&ir, &fixture_config("vue"));
assert_eq!(files.len(), 1);
assert_byte_equal(&files[0].content, "tests/fixtures/baselines/vue/vue.ts", "vue.ts");
}
#[test]
fn svelte_target_byte_match() {
let ir = load_ir();
let files = SvelteAdapter.emit(&ir, &fixture_config("svelte"));
assert_eq!(files.len(), 1);
assert_byte_equal(&files[0].content, "tests/fixtures/baselines/svelte/svelte.ts", "svelte.ts");
}