@aklinker1/zeta 1.3.3 → 2.0.0

package/src/types.ts

@@ -434,11 +434,20 @@ export type RouterData = {
   def?: RouteDef;
   route: string;
   hooks: LifeCycleHooks;
+  compiledHandler: CompiledRouteHandler;
 } & (
   | { fetch: ServerSideFetch }
   | { handler: (ctx: OnBeforeHandleContext) => Promise<any> }
 );
 
+/**
+ * Function type called internally once a route is matched for a request.
+ */
+export type CompiledRouteHandler = (
+  request: Request,
+  ctx: any,
+) => MaybePromise<Response>;
+
 //
 // HANDLERS
 //
@@ -512,9 +521,7 @@ export type LifeCycleHook<TCallback extends Function> = {
  * into the handler context.
  */
 export type OnGlobalRequestHook = LifeCycleHook<
-  (
-    ctx: Simplify<OnGlobalRequestContext>,
-  ) => MaybePromise<Record<string, any> | void>
+  (ctx: Simplify<OnGlobalRequestContext>) => Record<string, any> | void
 >;
 
 /**
@@ -560,27 +567,29 @@ export type OnMapResponseHook = LifeCycleHook<
  * Zeta will handle any `HttpError`s thrown, but you can handle your own errors
  * here.
  */
-export type OnGlobalErrorHooks = LifeCycleHook<
-  (ctx: Simplify<OnGlobalErrorContext>) => MaybePromise<void>
+export type OnGlobalErrorHook = LifeCycleHook<
+  (ctx: Simplify<OnGlobalErrorContext>) => void
 >;
 
 /**
  * Called after the response is sent back to the client.
  */
 export type OnGlobalAfterResponseHook = LifeCycleHook<
-  (ctx: Simplify<AfterResponseContext>) => MaybePromise<void>
+  (ctx: Simplify<AfterResponseContext>) => void
 >;
 
 export type LifeCycleHooks = {
-  onGlobalRequest: OnGlobalRequestHook[];
-  onTransform: OnTransformHook[];
-  onBeforeHandle: OnBeforeHandleHook[];
-  onAfterHandle: OnAfterHandleHook[];
-  onMapResponse: OnMapResponseHook[];
-  onGlobalError: OnGlobalErrorHooks[];
-  onGlobalAfterResponse: OnGlobalAfterResponseHook[];
+  onGlobalRequest?: OnGlobalRequestHook[];
+  onTransform?: OnTransformHook[];
+  onBeforeHandle?: OnBeforeHandleHook[];
+  onAfterHandle?: OnAfterHandleHook[];
+  onMapResponse?: OnMapResponseHook[];
+  onGlobalError?: OnGlobalErrorHook[];
+  onGlobalAfterResponse?: OnGlobalAfterResponseHook[];
 };
 
+export type LifeCycleHookName = keyof LifeCycleHooks;
+
 //
 // BASE TYPES
 //
@@ -1028,17 +1037,6 @@ export interface SchemaAdapter {
    * @returns The JSON schema.
    */
   toJsonSchema: (schema: any) => any;
-  /**
-   * Used to pull out the openapi parameters from a schema.
-   * @param schema The schema to parse.
-   * @returns An array of objects used to generate the OpenAPI docs.
-   */
-  parseParamsRecord: (schema: StandardSchemaV1) => Array<{
-    name: string;
-    optional: boolean;
-    schema: StandardSchemaV1;
-    description?: string;
-  }>;
   getMeta: (schema: StandardSchemaV1) => Record<string, any> | undefined;
 }
 

package/src/internal/call-handler.ts

@@ -1,139 +0,0 @@
-import type { MatchedRoute } from "rou3";
-import type { RouterData, SchemaAdapter } from "../types";
-import { NotFoundHttpError } from "../errors";
-import {
-  callCtxModifierHooks,
-  getRawParams,
-  getRawQuery,
-  isStatusResult,
-  IsStatusResult,
-  validateInputSchema,
-  validateOutputSchema,
-} from "./utils";
-import { smartDeserialize, smartSerialize } from "./serialization";
-import { getMeta } from "../meta";
-
-export async function callHandler(
-  ctx: any,
-  getRoute: (
-    method: string,
-    path: string,
-  ) => MatchedRoute<RouterData> | undefined,
-  schemaAdapter: SchemaAdapter | undefined,
-): Promise<Response> {
-  const route = getRoute(ctx.method, ctx.path);
-  if (route == null) {
-    throw new NotFoundHttpError(undefined, {
-      method: ctx.method,
-      path: ctx.path,
-    });
-  }
-
-  if ("fetch" in route.data) {
-    const res = route.data.fetch(ctx.request);
-    return res instanceof Promise ? await res : res;
-  }
-
-  const rawBody = await smartDeserialize(ctx.request);
-  const rawQuery = getRawQuery(ctx.url);
-  const rawParams = getRawParams(route);
-  ctx.route = route.data.route;
-  ctx.params = rawParams;
-  ctx.query = rawQuery;
-  ctx.body = rawBody;
-
-  if (route.data.hooks.onTransform.length > 0) {
-    const onTransformResponse = await callCtxModifierHooks(
-      ctx,
-      route.data.hooks.onTransform,
-    );
-    if (onTransformResponse) return onTransformResponse;
-  }
-
-  if (route.data.def?.body)
-    ctx.body = validateInputSchema(route.data.def?.body, rawBody);
-  if (route.data.def?.query)
-    ctx.query = validateInputSchema(route.data.def?.query, rawQuery);
-  if (route.data.def?.params)
-    ctx.params = validateInputSchema(route.data.def?.params, rawParams);
-
-  if (route.data.hooks.onBeforeHandle.length > 0) {
-    const res = await callCtxModifierHooks(
-      ctx,
-      route.data.hooks.onBeforeHandle,
-    );
-    if (res) return res;
-  }
-
-  ctx.status = (status: number, body: any) => ({
-    [IsStatusResult]: true,
-    status,
-    body,
-  });
-
-  {
-    let response: any = route.data.handler(ctx);
-    if (response instanceof Promise) response = await response;
-
-    ctx.response = response;
-  }
-
-  for (const hook of route.data.hooks.onAfterHandle) {
-    let res = hook.callback(ctx);
-    res = res instanceof Promise ? await res : res;
-    if (res instanceof Response) return res;
-    ctx.response = res;
-  }
-
-  let responseMeta: Record<string, any> | undefined;
-  if (!(ctx.response instanceof Response)) {
-    if (route.data.def?.responses) {
-      if ("~standard" in route.data.def.responses) {
-        ctx.response = validateOutputSchema(
-          route.data.def.responses,
-          ctx.response,
-        );
-        responseMeta = getMeta(schemaAdapter, route.data.def.responses);
-      } else {
-        if (!ctx.response || !isStatusResult(ctx.response)) {
-          throw new Error(
-            "When `responses` is a record of schemas, you must return a value from `ctx.status(...)`.",
-          );
-        }
-        const { status, body } = ctx.response;
-        const schema = route.data.def.responses[status];
-        if (!schema) {
-          // This should be caught by the `status` function's type definition, but it's here as a safeguard.
-          throw new Error(`No response schema found for status ${status}.`);
-        }
-        ctx.set.status = status;
-        ctx.response = validateOutputSchema(schema, body);
-        responseMeta = getMeta(schemaAdapter, schema);
-      }
-    }
-  }
-
-  if (ctx.response instanceof Response) return ctx.response;
-
-  for (const hook of route.data.hooks.onMapResponse) {
-    let res = hook.callback(ctx);
-    res = res instanceof Promise ? await res : res;
-    if (res instanceof Response) return res;
-    ctx.response = res;
-  }
-
-  const resBody = smartSerialize(ctx.response);
-  if (!resBody)
-    return new Response(undefined, {
-      status: ctx.set.status,
-      headers: ctx.set.headers,
-    });
-
-  return new Response(resBody.serialized, {
-    status: ctx.set.status,
-    headers: {
-      "Content-Type": responseMeta?.contentType ?? resBody.contentType,
-      ...ctx.set.headers,
-    },
-  });
-}