57 lines
2.8 KiB
TypeScript
57 lines
2.8 KiB
TypeScript
// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
|
|
//
|
|
// Usage:
|
|
//
|
|
// import "zod/compile";
|
|
// import * as z from "zod";
|
|
// // every schema constructed below this is compiled on first parse
|
|
//
|
|
// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
|
|
//
|
|
// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_zod.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
|
|
|
|
import { compile } from "./v4/core/compile.js";
|
|
import * as core from "./v4/core/index.js";
|
|
|
|
let compiling = false;
|
|
|
|
core.globalConfig.postProcessor = (inst: any) => {
|
|
if (compiling) return;
|
|
const originalRun = inst._zod?.run;
|
|
if (typeof originalRun !== "function") return;
|
|
|
|
const shim = (payload: any, ctx: any): any => {
|
|
// Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
|
|
if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
|
|
return originalRun(payload, ctx);
|
|
}
|
|
|
|
compiling = true;
|
|
try {
|
|
// Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
|
|
if (core.globalConfig.jitless) {
|
|
inst._zod.run = originalRun;
|
|
return originalRun(payload, ctx);
|
|
}
|
|
// Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
|
|
const compiled = compile(inst, { strict: true });
|
|
// Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
|
|
inst._zod.run = compiled._zod.run;
|
|
inst._zod.bag.fallbackRun = compiled._zod.bag.fallbackRun;
|
|
inst._zod.bag.validator = compiled._zod.bag.validator;
|
|
} catch {
|
|
// Permanent fallback for unsupported schemas.
|
|
inst._zod.run = originalRun;
|
|
} finally {
|
|
compiling = false;
|
|
}
|
|
|
|
return inst._zod.run(payload, ctx);
|
|
};
|
|
|
|
// Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
|
|
(shim as any).__originalRun = originalRun;
|
|
|
|
inst._zod.run = shim;
|
|
};
|