157 lines
4.8 KiB
TypeScript
157 lines
4.8 KiB
TypeScript
'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'
|