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

mizan-tauri + Pydantic-aware codegen: Tauri-as-Mizan-backend substrate

Browse Source 
Tauri now joins FastAPI/Django/axum as a first-class Mizan backend. The
React frontend calls Mizan-registered functions through Tauri's IPC
with the same {result, invalidate, merge} envelope the HTTP path uses;
the schema flows Pydantic → decoru → Rust → KDL → TS in one
mizan-generate invocation.

New packages:
* backends/mizan-tauri — Tauri plugin exposing a single `mizan_invoke`
  command that routes through mizan-core's FUNCTIONS / CONTEXTS
  registries. No per-function tauri::command; the linkme slice IS the
  dispatch table.
* frontends/mizan-tauri-transport — TS package exporting
  tauriTransport() that wraps invoke('plugin:mizan|mizan_invoke', ...)
  and re-shapes errors into MizanError. Pairs with mizan-tauri.

@mizan/base — pluggable transport:
* Adds MizanTransport interface + transport config field.
* Existing fetch-based body factored into httpTransport() (default).
* mizanCall/mizanFetch delegate to config.transport; merge/invalidate
  side-effects stay in the kernel (transport-agnostic).
* Consumers swap via configure({ transport: tauriTransport() }).

mizan-codegen — Rust source + Pydantic pre-step:
* [source.rust] runs a Cargo bin (cargo run --bin <name>) and parses
  KDL from stdout. The bin uses mizan_core::build_ir() after
  force-linking the consumer's #[derive(Mizan)] / #[mizan::client]
  registrations.
* [source.rust.pydantic] is an optional pre-step that pipes an
  embedded Python bridge (scripts/run_decoru.py) to python and writes
  decoru-emitted Rust types into the consumer crate. The bridge
  auto-discovers BaseModel subclasses AND Enum subclasses
  (last-variant-is-default convention so decoru's impl Default keeps
  compiling against enum-typed fields without explicit Pydantic
  defaults).
* Pure-Rust usage stays intact — omit pydantic block and write Rust
  types by hand.

mizan-macros:
* #[mizan::client] now supports Result<T, MizanError> returns. The
  dispatch wrapper `?`-unwraps the user fn so server-side errors
  surface as the protocol's standard {code, message, details?}
  envelope; T-returning functions stay unchanged.
* #[derive(Mizan)] strips the r# raw-identifier prefix and honors
  field-level #[serde(rename = "...")] when emitting IR field names.
  Matches serde's wire shape — fixes IR-vs-JSON drift for Rust-keyword
  fields (e.g. `r#type` → `type`).

react.tsx template:
* Conditionally emits context-related imports / useContextSubscription
  helper based on has_global || !named_contexts.is_empty(). Consumers
  without contexts (mutation/RPC-only apps like claude-manage) no
  longer get dead imports that trip noUnusedLocals.

Verified end-to-end: cargo build clean across mizan-tauri,
mizan-codegen, AFI rust_app; AFI three-way KDL parity tests pass;
claude-manage migration drives the full stack (Pydantic schema →
generated TS api → Tauri-IPC transport → mizan-core dispatch).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ryth Azhur
2026-05-19 19:01:45 -04:00
parent 54f060c273
commit 22dcf0e3c1
13 changed files with 5478 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
frontends/mizan-base/src/index.ts
View File

@@ -30,6 +30,39 @@ export class MizanError extends Error {
}
}
// === Transport ===
/**
* Wire surface the kernel uses to reach a Mizan backend. The default
* implementation is `httpTransport()` (POST /call/, GET /ctx/). Tauri
* apps swap in `tauriTransport()` from `@mizan/tauri-transport`. Any
* future transport — workers, edge runtimes, channels — implements this
* interface and replaces the default via `configure({ transport })`.
*/
export interface MizanTransport {
/** RPC dispatch — invokes a Mizan-registered function. */
call(
fnName: string,
args: Record<string, any>,
): Promise<MizanCallResponse>
/** Context-bundle fetch — invokes a Mizan-registered context. */
fetch(
contextName: string,
params?: Record<string, any>,
): Promise<any>
}
/**
* Raw envelope a transport returns from `call()`. The kernel uses the
* `merge` and `invalidate` arrays to drive client-side cache updates;
* `result` is the function's typed return value.
*/
export interface MizanCallResponse {
result: any
invalidate?: Array<string | { context: string; params?: Record<string, any> } | { function: string }>
merge?: Array<{ context: string; slot: string; value: unknown; params?: Record<string, any> }>
}
// === Configuration ===
interface MizanConfig {
@@ -45,6 +78,13 @@ interface MizanConfig {
* this onto the schema-advertised capability surface.
*/
session: boolean
/**
* Wire transport. Defaults to `httpTransport()` (fetch-based,
* compatible with FastAPI / Django backends). Swap with a custom
* transport (e.g. `tauriTransport()`) at app entry to route
* Mizan calls through a different channel.
*/
transport: MizanTransport
}
const config: MizanConfig = {
@@ -53,6 +93,8 @@ const config: MizanConfig = {
csrfCookieName: 'csrftoken',
csrfHeaderName: 'X-CSRFToken',
session: true,
// Initialized below once httpTransport is defined.
transport: null as unknown as MizanTransport,
}
export function configure(opts: Partial<MizanConfig>): void {
@@ -344,42 +386,68 @@ async function resolveHeaders(): Promise<Record<string, string>> {
}
}
/**
* Default Mizan transport — POST `${baseUrl}/call/` and GET
* `${baseUrl}/ctx/${name}/`. Compatible with `mizan-fastapi`,
* `mizan-django`, and `mizan-rust-axum`. Swap with a different
* transport via `configure({ transport })` when running in a
* non-HTTP host (e.g. Tauri).
*/
export function httpTransport(): MizanTransport {
return {
async call(functionName, args) {
const headers = await resolveHeaders()
headers['Content-Type'] = 'application/json'
const res = await fetch(`${config.baseUrl}/call/`, {
method: 'POST',
headers,
credentials: 'same-origin',
body: JSON.stringify({ fn: functionName, args }),
})
if (!res.ok) throw new MizanError(res.status, await res.text())
return res.json()
},
async fetch(contextName, params) {
const url = new URL(
`${config.baseUrl}/ctx/${contextName}/`,
typeof globalThis.location !== 'undefined'
? globalThis.location.origin
: 'http://localhost',
)
if (params) {
for (const [k, v] of Object.entries(params)) {
url.searchParams.set(k, String(v))
}
}
const headers = await resolveHeaders()
const res = await fetchWithRetry(url.toString(), {
headers,
credentials: 'same-origin',
})
if (!res.ok) throw new MizanError(res.status, await res.text())
return res.json()
},
}
}
// Install the default transport now that httpTransport is in scope. The
// config object was constructed earlier with a placeholder so the type
// stayed honest; this line is the actual binding.
config.transport = httpTransport()
export async function mizanFetch(
contextName: string,
params?: Record<string, any>,
): Promise<any> {
const url = new URL(
`${config.baseUrl}/ctx/${contextName}/`,
typeof globalThis.location !== 'undefined' ? globalThis.location.origin : 'http://localhost',
)
if (params) {
for (const [k, v] of Object.entries(params)) {
url.searchParams.set(k, String(v))
}
}
const headers = await resolveHeaders()
const res = await fetchWithRetry(url.toString(), { headers, credentials: 'same-origin' })
if (!res.ok) throw new MizanError(res.status, await res.text())
return res.json()
return config.transport.fetch(contextName, params)
}
export async function mizanCall(
functionName: string,
args: Record<string, any>,
): Promise<any> {
const headers = await resolveHeaders()
headers['Content-Type'] = 'application/json'
const res = await fetch(`${config.baseUrl}/call/`, {
method: 'POST',
headers,
credentials: 'same-origin',
body: JSON.stringify({ fn: functionName, args }),
})
if (!res.ok) throw new MizanError(res.status, await res.text())
const data = await res.json()
const data = await config.transport.call(functionName, args)
// Server-driven merges run before invalidations so a context that is
// both merged-into and invalidated ends in the invalidation state — the
@@ -395,9 +463,12 @@ export async function mizanCall(
for (const entry of data.invalidate) {
if (typeof entry === 'string') {
invalidate(entry)
} else {
} else if ('context' in entry) {
invalidate(entry.context, entry.params)
}
// {function: name} entries route through the kernel's
// function-output cache layer, which lives in the framework
// adapter; mizan-base treats them as a no-op here.
}
}

15
frontends/mizan-tauri-transport/package.json Normal file
View File

@@ -0,0 +1,15 @@
{
"name": "@mizan/tauri-transport",
"version": "0.1.0",
"description": "Mizan transport adapter routing calls through Tauri's IPC instead of HTTP. Paired with the `mizan-tauri` Rust plugin.",
"type": "module",
"main": "src/index.ts",
"exports": {
".": "./src/index.ts"
},
"peerDependencies": {
"@mizan/base": "*",
"@tauri-apps/api": "^2"
},
"license": "MIT"
}

81
frontends/mizan-tauri-transport/src/index.ts Normal file
View File

@@ -0,0 +1,81 @@
/**
* @mizan/tauri-transport — routes Mizan calls through Tauri's IPC
* instead of HTTP fetch. Paired with the `mizan-tauri` Rust plugin
* (which exposes a single `mizan_invoke` command).
*
* Usage:
*
* import { configure } from '@mizan/base'
* import { tauriTransport } from '@mizan/tauri-transport'
*
* configure({ transport: tauriTransport() })
*
* The transport keeps the same protocol surface as the HTTP transport
* (call/fetch envelopes, {result, invalidate, merge} response shape),
* so the codegen output and React adapter are unchanged — only the
* wire channel differs.
*/
import { invoke } from '@tauri-apps/api/core'
import { MizanError, type MizanCallResponse, type MizanTransport } from '@mizan/base'
/** Plugin-prefixed Tauri command — `init()` on the Rust side installs
* the plugin under the name `mizan`, so the dispatch command is
* reachable from JS as `plugin:mizan|mizan_invoke`. */
const COMMAND = 'plugin:mizan|mizan_invoke'
type TauriError = {
code?: string
message?: string
details?: unknown
}
/**
* Wrap a `mizan-tauri` error payload into a `MizanError` so consumers
* see one error surface regardless of transport. Tauri's invoke()
* rejects with the raw `Err` payload from the Rust command; we re-shape
* it to the same `{error: {code, message, details}}` envelope the HTTP
* transport surfaces.
*/
function wrapError(raw: unknown): MizanError {
if (raw && typeof raw === 'object') {
const err = raw as TauriError
const body = JSON.stringify({ error: { code: err.code, message: err.message, details: err.details } })
// 0 means "no HTTP status" — the IPC transport bypassed the
// protocol's HTTP layer. The error envelope still carries
// .code/.message/.details so consumers don't have to special-case.
return new MizanError(0, body)
}
return new MizanError(0, JSON.stringify({ error: { message: String(raw) } }))
}
/**
* Build a Mizan transport that routes through Tauri's IPC. Install via:
*
* import { configure } from '@mizan/base'
* import { tauriTransport } from '@mizan/tauri-transport'
* configure({ transport: tauriTransport() })
*/
export function tauriTransport(): MizanTransport {
return {
async call(fnName, args): Promise<MizanCallResponse> {
try {
const data = await invoke<MizanCallResponse>(COMMAND, {
envelope: { op: 'call', fn: fnName, args },
})
return data
} catch (e) {
throw wrapError(e)
}
},
async fetch(contextName, params) {
try {
return await invoke(COMMAND, {
envelope: { op: 'fetch', context: contextName, params: params ?? {} },
})
} catch (e) {
throw wrapError(e)
}
},
}
}