mirror of
https://github.com/vercel-labs/scriptc.git
synced 2026-11-05 08:13:06 +08:00
Malte UblandClaude Opus 5.5
dddcbed335
The declaration-typed boundary already reaches zod 4 schemas and hono's
c.req.valid(): zod 4's z.infer and hono's validator Input generics resolve
to plain object types in the declaration world. Three gaps remained:
- Boolean literal types printed as `false` (the TS7 facade leaves
intrinsicName unset), so `{ ok: true } | { ok: false }` lost its true
arm and `boolean | undefined` became `undefined | false`. The printer
reads the literal's value.
- `r.data` after `const r = S.safeParse(x); if (r.success)` never
crossed: zod 4's result union is not data (its error arm is a class),
and reads on projectable receivers were skipped on the assumption that
something else types the receiver. Such reads now cross when the
receiver is a package call whose type does not project, or a const
bound to one.
- Reads through bindings annotated with a projected type no longer get a
redundant cast, and aliases are named only for casts that survive.
New npm cases zod4-boundary and hono-zod-validator run real zod 4.6.7,
hono 4.13.13 and @hono/zod-validator 0.9.1 (vendored file closures) under
Node and natively; decl-boundary.test.ts checks that c.req.valid() is a
checked cast with a path TypeError.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
51 lines
1.6 KiB
JavaScript
51 lines
1.6 KiB
JavaScript
//#region src/compose.ts
|
|
/**
|
|
* Compose middleware functions into a single function based on `koa-compose` package.
|
|
*
|
|
* @template E - The environment type.
|
|
*
|
|
* @param {[[Function, unknown], unknown][] | [[Function]][]} middleware - An array of middleware functions and their corresponding parameters.
|
|
* @param {ErrorHandler<E>} [onError] - An optional error handler function.
|
|
* @param {NotFoundHandler<E>} [onNotFound] - An optional not-found handler function.
|
|
*
|
|
* @returns {(context: Context, next?: Next) => Promise<Context>} - A composed middleware function.
|
|
*/
|
|
const compose = (middleware, onError, onNotFound) => {
|
|
return (context, next) => {
|
|
let index = -1;
|
|
return dispatch(0);
|
|
/**
|
|
* Dispatch the middleware functions.
|
|
*
|
|
* @param {number} i - The current index in the middleware array.
|
|
*
|
|
* @returns {Promise<Context>} - A promise that resolves to the context.
|
|
*/
|
|
async function dispatch(i) {
|
|
if (i <= index) throw new Error("next() called multiple times");
|
|
index = i;
|
|
let res;
|
|
let isError = false;
|
|
let handler;
|
|
if (middleware[i]) {
|
|
handler = middleware[i][0][0];
|
|
context.req.routeIndex = i;
|
|
} else handler = i === middleware.length && next || void 0;
|
|
if (handler) try {
|
|
res = await handler(context, () => dispatch(i + 1));
|
|
} catch (err) {
|
|
if (err instanceof Error && onError) {
|
|
context.error = err;
|
|
res = await onError(err, context);
|
|
isError = true;
|
|
} else throw err;
|
|
}
|
|
else if (context.finalized === false && onNotFound) res = await onNotFound(context);
|
|
if (res && (context.finalized === false || isError)) context.res = res;
|
|
return context;
|
|
}
|
|
};
|
|
};
|
|
//#endregion
|
|
export { compose };
|