@aklinker1/zeta 1.3.2 → 2.0.0

package/src/internal/compile-route-handler.ts

@@ -0,0 +1,190 @@
+import type { MaybePromise } from "elysia";
+import type {
+  CompiledRouteHandler,
+  LifeCycleHookName,
+  LifeCycleHooks,
+  OnBeforeHandleContext,
+  RouteDef,
+  SchemaAdapter,
+  ServerSideFetch,
+} from "../types";
+import { smartDeserialize, smartSerialize } from "./serialization";
+import {
+  cleanupCompiledWhitespace,
+  IsStatusResult,
+  validateInputSchema,
+  validateOutputSchema,
+} from "./utils";
+import { getMeta } from "../meta";
+
+export function compileRouteHandler(
+  options: CompileOptions,
+): CompiledRouteHandler {
+  if (options.fetch) {
+    return new Function(`
+      return (request, ctx) => ctx.matchedRoute.data.fetch(request)
+      //#sourceURL=${getSourceUrl(options)}
+    `)();
+  }
+
+  const responseContentTypeMap = getResponseContentTypeMap(options);
+
+  const js = `
+return async (request, ctx) => {
+  ${options.method === "GET" ? "" : ADD_CTX_BODY}
+
+${options.hooks.onTransform?.length ? compileCtxModifierHookCall("onTransform", options.hooks.onTransform.length) : ""}
+
+  ${options.def?.body ? "ctx.body = utils.validateInputSchema(ctx.matchedRoute.data.def.body, ctx.body);" : ""}
+  ${options.def?.params ? "ctx.params = utils.validateInputSchema(ctx.matchedRoute.data.def.params, ctx.params);" : ""}
+  ${options.def?.query ? "ctx.query = utils.validateInputSchema(ctx.matchedRoute.data.def.query, ctx.query);" : ""}
+
+${options.hooks.onBeforeHandle?.length ? compileCtxModifierHookCall("onBeforeHandle", options.hooks.onBeforeHandle.length) : ""}
+
+  ctx.response = await ctx.matchedRoute.data.handler(ctx);
+  if (ctx.response) {
+    if (ctx.response[utils.IsStatusResult]) {
+      ctx.set.status = ctx.response.status;
+      ctx.response = ctx.response.body;
+    }
+    if (typeof ctx.response?.body?.bytes === utils.FUNCTION) return ctx.response;
+  }
+
+  ${compileValidateResponse(options)}
+
+${options.hooks.onAfterHandle?.length ? compileResponseModifierHookCall("onAfterHandle", options.hooks.onAfterHandle.length) : ""}
+
+${options.hooks.onMapResponse?.length ? compileResponseModifierHookCall("onMapResponse", options.hooks.onMapResponse.length) : ""}
+
+  if (ctx.response == null) {
+    return new Response(undefined, {
+      status: ctx.set.status,
+      headers: ctx.set.headers,
+    })
+  }
+
+  const serialized = utils.smartSerialize(ctx.response);
+  if (!ctx.set.headers["Content-Type"]) ctx.set.headers["Content-Type"] = ${responseContentTypeMap ? "responseContentTypeMap[ctx.set.status] ??" : ""} serialized.contentType
+  return new Response(serialized.value, {
+    status: ctx.set.status,
+    headers: ctx.set.headers,
+  })
+}
+//#sourceURL=${getSourceUrl(options)}
+  `;
+  return new Function(
+    "utils",
+    "responseContentTypeMap",
+    cleanupCompiledWhitespace(js),
+  )(UTILS, responseContentTypeMap);
+}
+
+// These functions are available in the generated code via the "utils" object.
+const UTILS = {
+  smartDeserialize,
+  smartSerialize,
+  FUNCTION: "function",
+  IsStatusResult,
+  validateInputSchema,
+  validateOutputSchema,
+};
+
+type CompileOptions = {
+  schemaAdapter: SchemaAdapter | undefined;
+  def: RouteDef | undefined;
+  method: string;
+  route: string;
+  hooks: LifeCycleHooks;
+  fetch?: ServerSideFetch;
+  handler?: (ctx: OnBeforeHandleContext) => MaybePromise<any>;
+};
+
+function getSourceUrl(options: CompileOptions) {
+  return `zeta-jit-generated://${options.method.toLowerCase()}-${options.route.replace(/\s/gm, "").replaceAll("/", "-")}.js`;
+}
+
+const ADD_CTX_BODY = `
+  ctx.body = utils.smartDeserialize(request);
+  if (ctx.body) ctx.body = await ctx.body;
+`;
+
+function compileCtxModifierHookCall(
+  hook: LifeCycleHookName,
+  hookCount: number,
+): string {
+  const lines: string[] = [];
+
+  for (let i = 0; i < hookCount; i++) {
+    const resultVar = `${hook}Res${i}`;
+    lines.push(
+      `  const ${resultVar} = await ctx.matchedRoute.data.hooks.${hook}[${i}].callback(ctx);`,
+      `  if (${resultVar})`,
+      `    if (typeof ${resultVar}.body?.bytes === utils.FUNCTION)`,
+      `      return ${resultVar};`,
+      `    else`,
+      `      for (const key of Object.keys(${resultVar}))`,
+      `        ctx[key] = ${resultVar}[key];`,
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function compileResponseModifierHookCall(
+  hook: LifeCycleHookName,
+  hookCount: number,
+): string {
+  const lines: string[] = [];
+
+  for (let i = 0; i < hookCount; i++) {
+    const resultVar = `${hook}Res${i}`;
+    lines.push(
+      `  const ${resultVar} = await ctx.matchedRoute.data.hooks.${hook}[${i}].callback(ctx);`,
+      `  if (${resultVar}) ctx.response = ${resultVar};`,
+      `  if (typeof ${resultVar}.body?.bytes === utils.FUNCTION)`,
+      `    return ${resultVar};`,
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function compileValidateResponse(options: CompileOptions): string {
+  // No schemas defined
+  if (!options.def?.responses) return "";
+
+  // One schema defined
+  if ("~standard" in options.def.responses)
+    return "ctx.response = utils.validateOutputSchema(ctx.matchedRoute.data.def.responses, ctx.response);";
+
+  // Multiple schemas based on the status code
+  return "ctx.response = utils.validateOutputSchema(ctx.matchedRoute.data.def.responses[ctx.set.status], ctx.response);";
+}
+
+function getResponseContentTypeMap(
+  options: CompileOptions,
+): Record<number, string> | undefined {
+  // No schemas defined
+  if (!options.def?.responses) return;
+
+  // One schema defined
+  if ("~standard" in options.def.responses) {
+    const { contentType } = getMeta(
+      options.schemaAdapter,
+      options.def.responses,
+    );
+    if (!contentType) return;
+
+    return { [200]: contentType };
+  }
+
+  // Multiple schemas based on the status code
+  const map: Record<number, string> = {};
+  for (const [status, schema] of Object.entries(options.def.responses)) {
+    const { contentType } = getMeta(options.schemaAdapter, schema);
+    map[Number(status)] = contentType;
+  }
+  if (Object.keys(map).length === 0) return;
+
+  return map;
+}

package/src/internal/context.ts

@@ -0,0 +1,47 @@
+import type { MatchedRoute } from "rou3";
+import { HttpStatus } from "../status";
+import type { RouterData, StatusResult } from "../types";
+import { getRawParams, getRawQuery, IsStatusResult } from "./utils";
+
+export class Context {
+  set = {
+    status: HttpStatus.Ok,
+    headers: {},
+  };
+
+  matchedRoute: MatchedRoute<RouterData> | undefined;
+
+  constructor(
+    public request: Request,
+    public path: string,
+    public origin: string,
+  ) {}
+
+  get url(): URL {
+    return new URL(this.request.url, this.origin);
+  }
+
+  get params(): Record<string, string> {
+    return this.matchedRoute?.params ? getRawParams(this.matchedRoute) : {};
+  }
+
+  get query(): Record<string, string> {
+    return this.request.url.includes("?") ? getRawQuery(this.request) : {};
+  }
+
+  get route(): string | undefined {
+    return this.matchedRoute?.data.route;
+  }
+
+  get method(): string {
+    return this.request.method;
+  }
+
+  status(status: number, body?: unknown): StatusResult {
+    return {
+      [IsStatusResult]: true,
+      status,
+      body,
+    };
+  }
+}

package/src/internal/serialization.ts

@@ -1,72 +1,71 @@
 export function smartSerialize(value: unknown):
   | {
       contentType: string | undefined;
-      serialized: BodyInit;
+      value: BodyInit;
     }
   | undefined {
   if (value == null) return undefined;
 
+  switch (typeof value) {
+    case "string":
+      return { contentType: "text/plain", value };
+    case "number":
+    case "boolean":
+    case "bigint":
+      return { contentType: "text/plain", value: String(value) };
+  }
+
   if (value instanceof FormData) {
     return {
       contentType: undefined, // Let fetch set the content type with a boundary
-      serialized: value,
+      value,
     };
   }
 
   if (value instanceof File) {
-    const serialized = new FormData();
-    serialized.append("file", value);
+    const form = new FormData();
+    form.append("file", value);
     return {
       contentType: undefined,
-      serialized,
+      value: form,
     };
   }
 
   if (typeof FileList !== "undefined" && value instanceof FileList) {
-    const serialized = new FormData();
+    const form = new FormData();
     for (let i = 0; i < value.length; i++) {
-      serialized.append("files", value.item(i)!);
+      form.append("files", value.item(i)!);
     }
     return {
       contentType: undefined,
-      serialized,
+      value: form,
     };
   }
 
   if (value instanceof Blob) {
     return {
       contentType: value.type,
-      serialized: value,
+      value,
     };
   }
 
-  switch (typeof value) {
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "string":
-      return { contentType: "text/plain", serialized: String(value) };
-    case "object":
-      return {
-        contentType: "application/json",
-        serialized: JSON.stringify(value),
-      };
-  }
-
-  throw Error(
-    "Could not serialize object for request: " + JSON.stringify(value),
-  );
+  return {
+    contentType: "application/json",
+    value: JSON.stringify(value),
+  };
 }
 
-export async function smartDeserialize(
+export function smartDeserialize(
   arg: Response | Request,
-): Promise<unknown> {
+): Promise<unknown> | undefined {
+  if (arg instanceof Request && arg.method === "GET") return;
+
   const contentType = arg.headers.get("content-type");
   if (contentType == null) return;
 
   // JSON
   if (contentType.startsWith("application/json")) {
-    return await arg.json();
+    return arg.json();
   }
 
   // Forms
@@ -74,17 +73,17 @@ export async function smartDeserialize(
     contentType.startsWith("application/x-www-form-urlencoded") ||
     contentType.startsWith("multipart/form-data")
   ) {
-    return await arg.formData();
+    return arg.formData();
   }
 
   // Text
   if (contentType.startsWith("text/")) {
-    return await arg.text();
+    return arg.text();
   }
 
   // Binary
   if (contentType.startsWith("application/octet-stream")) {
-    return await arg.arrayBuffer();
+    return arg.arrayBuffer();
   }
 
   // Unknown

package/src/internal/utils.ts

@@ -1,6 +1,10 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { HttpError, ValidationGlobalError } from "../errors";
+import type { MatchedRoute } from "rou3";
+import { HttpError } from "../errors";
+import type { ErrorResponse } from "../schema";
 import { HttpStatus } from "../status";
+import { createBunTransport } from "../transports/bun-transport";
+import { createDenoTransport } from "../transports/deno-transport";
 import type {
   App,
   LifeCycleHook,
@@ -9,38 +13,28 @@ import type {
   StatusResult,
   Transport,
 } from "../types";
-import type { MatchedRoute } from "rou3";
-import type { ErrorResponse } from "../schema";
-import { createBunTransport } from "../transports/bun-transport";
-import { createDenoTransport } from "../transports/deno-transport";
 
 export function validateSchema<T>(
   schema: StandardSchemaV1<T, T>,
   input: unknown,
+  status: number,
+  message: string,
 ): T {
-  let res = schema["~standard"].validate(input);
+  const res = schema["~standard"].validate(input);
   if (res instanceof Promise) throw Error("Async validation not supported");
 
-  if (res.issues) throw new ValidationGlobalError(input, res.issues);
+  if (res.issues)
+    throw new HttpError(status, message, {
+      issues: res.issues,
+      input: input,
+    });
 
   return res.value;
 }
 
-function createHttpSchemaValidator(status: HttpStatus, message: string) {
-  return <T>(schema: StandardSchemaV1<T, T>, input: unknown): T => {
-    try {
-      return validateSchema<T>(schema, input);
-    } catch (err) {
-      if (err instanceof ValidationGlobalError) {
-        throw new HttpError(status, message, {
-          issues: err.issues,
-          input: err.input,
-        });
-      } else {
-        throw err;
-      }
-    }
-  };
+function createHttpSchemaValidator(status: number, message: string) {
+  return <T>(schema: StandardSchemaV1<T, T>, input: unknown): T =>
+    validateSchema<T>(schema, input, status, message);
 }
 
 export const validateInputSchema = createHttpSchemaValidator(
@@ -56,32 +50,55 @@ export function isApp(obj: unknown): obj is App<any> {
   return (obj as any)[Symbol.toStringTag] === "ZetaApp";
 }
 
-export function getRawQuery(url: URL): Record<string, string> {
-  const query: Record<string, string> = {};
-  const params = url.searchParams;
-  const entries = params.entries();
+export function getRawPathname(request: Request): string {
+  // Fast path for common case: http://host/path
+  const start = request.url.indexOf("/", 8); // Skip 'http://' or 'https://'
+  if (start === -1) return "/";
+
+  // Find end of pathname (before ? or #)
+  for (let i = start + 1; i < request.url.length; i++) {
+    if (request.url[i] === "?" || request.url[i] === "#") {
+      return request.url.slice(start, i);
+    }
+  }
+  return request.url.slice(start);
+}
 
-  for (const entry of entries) query[entry[0]] = entry[1];
-  return query;
+export function getRawQuery(request: Request): Record<string, string> {
+  let index = request.url.indexOf("?");
+  if (index === -1) return {};
+
+  const res: Record<string, string> = {};
+  const str = request.url;
+  const len = str.length;
+  let start = index + 1;
+
+  for (let i = start; i < len; i++) {
+    if (str[i] === "&" || i === len - 1) {
+      const end = i === len - 1 ? len : i;
+      const eqIndex = str.indexOf("=", start);
+      if (eqIndex !== -1 && eqIndex < end) {
+        res[str.slice(start, eqIndex)] = str.slice(eqIndex + 1, end);
+      }
+      start = i + 1;
+    }
+  }
+  return res;
 }
 
 export function getRawParams(
   route: MatchedRoute<RouterData>,
 ): Record<string, string> {
-  const rawParams = route.params ?? {};
-  // Rename _ to ** for validation and consistency
-  if ("_" in rawParams) {
-    rawParams["**"] = rawParams["_"];
-    delete rawParams["_"];
+  const params = route.params;
+  if (!params) return {};
+
+  const res: Record<string, string> = {};
+  for (const key in params) {
+    // Rename rou3's _ to ** to match type-system
+    const outKey = key === "_" ? "**" : key;
+    res[outKey] = decodeURIComponent(params[key]);
   }
-
-  // Decode all values automatically
-  return Object.fromEntries(
-    Object.entries(rawParams).map(([key, value]) => [
-      key,
-      decodeURIComponent(value),
-    ]),
-  );
+  return res;
 }
 
 export function getErrorStack(err: Error): string[] | undefined {
@@ -122,15 +139,17 @@ export function serializeErrorResponse(err: unknown): ErrorResponse {
 
 export async function callCtxModifierHooks(
   ctx: any,
-  hooks: LifeCycleHook<
-    (ctx: any) => MaybePromise<Record<string, any> | void>
-  >[],
+  hooks:
+    | LifeCycleHook<(ctx: any) => MaybePromise<Record<string, any> | void>>[]
+    | undefined,
 ): Promise<Response | undefined> {
+  if (!hooks) return;
+
   for (const hook of hooks) {
     let res = hook.callback(ctx);
-    res = res instanceof Promise ? await res : res;
+    if (res instanceof Promise) res = await res;
     if (res instanceof Response) return res;
-    if (res) Object.assign(ctx, res);
+    if (res) Object.assign(ctx, res); // TODO: Replace with manual property setting for performance?
   }
 }
 
@@ -158,3 +177,15 @@ export function detectTransport(): Transport {
     app.listen();
     ---`);
 }
+
+export function cleanupCompiledWhitespace(code: string): string {
+  return (
+    code
+      // Remove lines only containing spaces
+      .replace(/^ +$/gm, "")
+      // Reduce multiple newlines to one
+      .replace(/\n\n+/gm, "\n\n")
+      // Remove blank lines after curly braces
+      .replaceAll("{\n\n", "{\n")
+  );
+}

package/src/open-api.ts

@@ -1,14 +1,15 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { OpenAPI } from "openapi-types";
-import type { App, BasePath, SchemaAdapter } from "./types";
+import { titleCase } from "scule";
 import type { CreateAppOptions } from "./app";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { getHttpStatusName } from "./status";
+import { getMeta } from "./meta";
 import {
   ErrorResponseJsonSchema,
   isZetaSchema,
   type ZetaSchema,
 } from "./schema";
-import { getMeta } from "./meta";
+import { getHttpStatusName } from "./status";
+import type { App, BasePath, SchemaAdapter } from "./types";
 
 export function buildOpenApiDocs(
   options: CreateAppOptions<any> | undefined,
@@ -39,11 +40,14 @@ export function buildOpenApiDocs(
     };
     for (const [method, methodEntry] of Object.entries(app["~zeta"].routes)) {
       for (const [path, routerData] of Object.entries(methodEntry)) {
-        const openApiPath = path
-          // Replace parameters with OpenAPI format
-          .replace(/\/:([^/]+)/g, "/{$1}")
-          // Remove trailing slash
-          .replace(/\/$/, "");
+        const openApiPath =
+          path
+            // Replace parameters with OpenAPI format
+            .replace(/\/:([^/]+)/g, "/{$1}")
+            // Remove trailing slash
+            .replace(/\/$/, "") ||
+          // Convert "" -> "/"
+          "/";
         const { headers, params, query, body, responses, ...openApiOperation } =
           routerData.def ?? {};
         docs.paths ??= {};
@@ -51,6 +55,11 @@ export function buildOpenApiDocs(
 
         (docs.paths[openApiPath] as any)[method.toLowerCase()] = {
           ...openApiOperation,
+          summary:
+            openApiOperation.summary ??
+            (openApiOperation.operationId
+              ? titleCase(openApiOperation.operationId)
+              : undefined),
           requestBody: body
             ? {
                 content: {
@@ -143,19 +152,25 @@ export function buildScalarHtml(
 function mapParameters(
   adapter: SchemaAdapter,
   schema: StandardSchemaV1 | undefined,
-  _in: "query" | "path" | "header",
+  in_: "query" | "path" | "header",
 ): OpenAPI.Parameters {
   if (!schema) return [];
 
-  return adapter
-    .parseParamsRecord(schema)
-    .map(({ schema, optional, description, name }) => ({
+  const openApiSchema = adapter.toJsonSchema(schema);
+  if (openApiSchema.type !== "object")
+    throw Error(
+      `Param in ${in_} must have { "type": "object", ... }, but got ${JSON.stringify(openApiSchema, null, 2)}`,
+    );
+
+  return Object.entries(openApiSchema.properties).map(
+    ([name, def]: [string, any]) => ({
       name,
-      in: _in,
-      description,
-      schema: adapter.toJsonSchema(schema),
-      required: !optional,
-    }));
+      in: in_,
+      description: def.description,
+      schema: def,
+      required: !!openApiSchema.required?.includes(name),
+    }),
+  );
 }
 
 function buildResponse(

package/src/schema.ts

@@ -222,8 +222,8 @@ export const UploadFileBody: ZetaSchema<File> = createZetaSchema<File>(
   },
 );
 
-export const UploadFilesBody: ZetaSchema<FormData, File[]> = createZetaSchema<
-  FormData,
+export const UploadFilesBody: ZetaSchema<FileList, File[]> = createZetaSchema<
+  FileList,
   File[]
 >(
   "UploadFilesBody",