@aklinker1/zeta 2.1.2 → 2.2.0

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "./app";
-export type { App } from "./types";
-export { ErrorResponse, NoResponse, type ZetaSchema } from "./schema";
-export * from "./status";
-export * from "./errors";

package/src/internal/compile-fetch-function.ts

@@ -1,166 +0,0 @@
-import type { MatchedRoute } from "rou3";
-import { HttpError, NotFoundHttpError } from "../errors";
-import { HttpStatus } from "../status";
-import type { LifeCycleHooks, RouterData, ServerSideFetch } from "../types";
-import { Context } from "./context";
-import {
-  cleanupCompiledWhitespace,
-  getRawPathname,
-  serializeErrorResponse,
-} from "./utils";
-
-export function compileFetchFunction(options: CompileOptions): ServerSideFetch {
-  const onGlobalRequestCount = options.hooks.onGlobalRequest?.length;
-  const onGlobalAfterResponseCount =
-    options.hooks.onGlobalAfterResponse?.length;
-  const onGlobalErrorCount = options.hooks.onGlobalError?.length;
-
-  const js = `
-return (request) => {
-  const path = utils.getRawPathname(request);
-  const ctx = new utils.Context(request, path, utils.origin);
-  ${onGlobalAfterResponseCount ? "let handlerReturnedPromise = false;" : ""}
-
-  try {
-${onGlobalRequestCount ? compileOnGlobalRequestHook(onGlobalRequestCount) : ""}
-
-    const matchedRoute = utils.getRoute(request.method, path);
-    if (matchedRoute == null) {
-      throw new utils.NotFoundHttpError(undefined, {
-        method: request.method,
-        path,
-      });
-    } else {
-      ctx.matchedRoute = matchedRoute;
-    }
-
-    ctx.response = matchedRoute.data.compiledHandler(request, ctx);
-    if (typeof ctx.response.then !== utils.FUNCTION) return ctx.response;
-
-    ${onGlobalAfterResponseCount ? "handlerReturnedPromise = true;" : ""}
-    return ctx.response.catch(error => {
-${onGlobalErrorCount ? compileOnGlobalErrorHook(onGlobalErrorCount, 3) : ""}
-
-${compileErrorResponse(3)}
-    })${onGlobalAfterResponseCount ? compileOnGlobalAfterResponsePromiseFinally(onGlobalAfterResponseCount, 2) : ""};
-  } catch (error) {
-${onGlobalErrorCount ? compileOnGlobalErrorHook(onGlobalErrorCount, 2) : ""}
-
-${compileErrorResponse(2)}
-  } ${onGlobalAfterResponseCount ? compileOnGlobalAfterResponseFinally(onGlobalAfterResponseCount, 1) : ""}
-}
-//#sourceURL=zeta-jit-generated://zeta-fetch-fn.js
-  `;
-  return new Function("utils", cleanupCompiledWhitespace(js))({
-    FUNCTION: "function",
-    getRawPathname,
-    hooks: options.hooks,
-    Context,
-    getRoute: options.getRoute,
-    NotFoundHttpError,
-    origin: options.origin,
-    HttpError,
-    HttpStatus,
-    serializeErrorResponse,
-  });
-}
-
-function compileOnGlobalRequestHook(hookCount: number): string {
-  const lines: string[] = [];
-
-  for (let i = 0; i < hookCount; i++) {
-    const resultVar = `onGlobalRequestRes${i}`;
-    lines.push(
-      `    const ${resultVar} = utils.hooks.onGlobalRequest[${i}].callback(ctx);`,
-      ...(process.env.NODE_ENV !== "production"
-        ? [
-            `    if (${resultVar} instanceof Promise)`,
-            `      console.warn("Warning: Promise returned from onGlobalRequest hook. Promises returned from onGlobalRequest are not awaited, ignoring the return value.");`,
-          ]
-        : []),
-      `    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 compileOnGlobalErrorHook(hookCount: number, tabs: number): string {
-  const indent = "  ".repeat(tabs);
-  const lines: string[] = [`${indent}ctx.error = error;`];
-
-  for (let i = 0; i < hookCount; i++) {
-    lines.push(`${indent}utils.hooks.onGlobalError[${i}].callback(ctx);`);
-  }
-
-  return lines.join("\n");
-}
-
-function compileOnGlobalAfterResponseFinally(
-  hookCount: number,
-  tabs: number,
-): string {
-  const indent = "  ".repeat(tabs);
-  return `finally {
-${indent}  if (!handlerReturnedPromise) {
-${compileOnGlobalAfterResponseHook(hookCount, tabs + 2)}
-${indent}  }
-${indent}}
-`;
-}
-
-function compileOnGlobalAfterResponsePromiseFinally(
-  hookCount: number,
-  tabs: number,
-): string {
-  const indent = "  ".repeat(tabs);
-  return `.finally(() => {
-${compileOnGlobalAfterResponseHook(hookCount, tabs + 1)}
-${indent}})`;
-}
-
-function compileOnGlobalAfterResponseHook(
-  hookCount: number,
-  tabs: number,
-): string {
-  const indent = "  ".repeat(tabs);
-  const lines: string[] = [`${indent}setTimeout(() => {`];
-
-  for (let i = 0; i < hookCount; i++) {
-    lines.push(
-      `${indent}  utils.hooks.onGlobalAfterResponse[${i}].callback(ctx);`,
-    );
-  }
-
-  lines.push(`${indent}})`);
-
-  return lines.join("\n");
-}
-
-function compileErrorResponse(tabs: number): string {
-  const indent = "  ".repeat(tabs);
-  return `${indent}const status =
-${indent}  error instanceof utils.HttpError
-${indent}    ? error.status
-${indent}    : utils.HttpStatus.InternalServerError;
-${indent}return (
-${indent}  ctx.response = Response.json(
-${indent}    utils.serializeErrorResponse(error),
-${indent}    { status, headers: ctx.set.headers },
-${indent}  )
-${indent});`;
-}
-
-type CompileOptions = {
-  hooks: LifeCycleHooks;
-  getRoute: (
-    method: string,
-    path: string,
-  ) => MatchedRoute<RouterData> | undefined;
-  origin: string;
-};

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

@@ -1,194 +0,0 @@
-import { getMeta } from "../meta";
-import type {
-  CompiledRouteHandler,
-  LifeCycleHookName,
-  LifeCycleHooks,
-  MaybePromise,
-  OnBeforeHandleContext,
-  RouteDef,
-  SchemaAdapter,
-  ServerSideFetch,
-} from "../types";
-import { smartDeserialize, smartSerialize } from "./serialization";
-import {
-  cleanupCompiledWhitespace,
-  IsStatusResult,
-  validateInputSchema,
-  validateOutputSchema,
-} from "./utils";
-
-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 (
-      ctx.response = 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 (
-    ctx.response = 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

@@ -1,65 +0,0 @@
-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;
-
-  // Private storage for overwritten values
-  #params: Record<string, any> | undefined;
-  #query: Record<string, any> | 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, any> {
-    if (this.#params !== undefined) {
-      return this.#params;
-    }
-    return this.matchedRoute?.params ? getRawParams(this.matchedRoute) : {};
-  }
-
-  set params(value: Record<string, any>) {
-    this.#params = value;
-  }
-
-  get query(): Record<string, any> {
-    if (this.#query !== undefined) {
-      return this.#query;
-    }
-    return this.request.url.includes("?") ? getRawQuery(this.request) : {};
-  }
-
-  set query(value: Record<string, any>) {
-    this.#query = value;
-  }
-
-  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,91 +0,0 @@
-export function smartSerialize(value: unknown):
-  | {
-      contentType: string | undefined;
-      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
-      value,
-    };
-  }
-
-  if (value instanceof File) {
-    const form = new FormData();
-    form.append("file", value);
-    return {
-      contentType: undefined,
-      value: form,
-    };
-  }
-
-  if (typeof FileList !== "undefined" && value instanceof FileList) {
-    const form = new FormData();
-    for (let i = 0; i < value.length; i++) {
-      form.append("files", value.item(i)!);
-    }
-    return {
-      contentType: undefined,
-      value: form,
-    };
-  }
-
-  if (value instanceof Blob) {
-    return {
-      contentType: value.type,
-      value,
-    };
-  }
-
-  return {
-    contentType: "application/json",
-    value: JSON.stringify(value),
-  };
-}
-
-export function smartDeserialize(
-  arg: Response | Request,
-): 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 arg.json();
-  }
-
-  // Forms
-  if (
-    contentType.startsWith("application/x-www-form-urlencoded") ||
-    contentType.startsWith("multipart/form-data")
-  ) {
-    return arg.formData();
-  }
-
-  // Text
-  if (contentType.startsWith("text/")) {
-    return arg.text();
-  }
-
-  // Binary
-  if (contentType.startsWith("application/octet-stream")) {
-    return arg.arrayBuffer();
-  }
-
-  // Unknown
-  throw Error(`Unknown content type: "${contentType}"`);
-}

package/src/internal/utils.ts

@@ -1,191 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-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,
-  MaybePromise,
-  RouterData,
-  StatusResult,
-  Transport,
-} from "../types";
-
-export function validateSchema<T>(
-  schema: StandardSchemaV1<T, T>,
-  input: unknown,
-  status: number,
-  message: string,
-): T {
-  const res = schema["~standard"].validate(input);
-  if (res instanceof Promise) throw Error("Async validation not supported");
-
-  if (res.issues)
-    throw new HttpError(status, message, {
-      issues: res.issues,
-      input: input,
-    });
-
-  return res.value;
-}
-
-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(
-  HttpStatus.BadRequest,
-  "Input validation failed",
-);
-export const validateOutputSchema = createHttpSchemaValidator(
-  HttpStatus.UnprocessableEntity,
-  "Output validation failed",
-);
-
-export function isApp(obj: unknown): obj is App<any> {
-  return (obj as any)[Symbol.toStringTag] === "ZetaApp";
-}
-
-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);
-}
-
-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 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]!);
-  }
-  return res;
-}
-
-export function getErrorStack(err: Error): string[] | undefined {
-  if (process.env.NODE_ENV === "production") return;
-  return err.stack
-    ?.split("\n")
-    .map((line) => line.trim())
-    .slice(1);
-}
-
-export function serializeErrorResponse(err: unknown): ErrorResponse {
-  if (err instanceof HttpError)
-    return {
-      status: err.status,
-      name: err.name,
-      message: err.message,
-      ...err.additionalInfo,
-      stack: getErrorStack(err),
-      cause: err.cause != null ? serializeErrorResponse(err.cause) : undefined,
-    };
-
-  if (err instanceof Error)
-    return {
-      status: HttpStatus.InternalServerError,
-      name: err.name,
-      message: err.message,
-      stack: getErrorStack(err),
-      cause: err.cause != null ? serializeErrorResponse(err.cause) : undefined,
-    };
-
-  return {
-    name: "Unknown Error",
-    message: "An unknown error occurred",
-    status: HttpStatus.InternalServerError,
-    stack: getErrorStack(err as Error),
-  };
-}
-
-export async function callCtxModifierHooks(
-  ctx: any,
-  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);
-    if (res instanceof Promise) res = await res;
-    if (res instanceof Response) return res;
-    if (res) Object.assign(ctx, res); // TODO: Replace with manual property setting for performance?
-  }
-}
-
-export const IsStatusResult = Symbol("IsStatusResult");
-
-export function isStatusResult(result: any): result is StatusResult {
-  return IsStatusResult in result;
-}
-
-export function detectTransport(): Transport {
-  // @ts-ignore: Bun types may not be available
-  if (typeof Bun !== "undefined") return createBunTransport();
-  // @ts-ignore: Deno types may not be available
-  if (typeof Deno !== "undefined") return createDenoTransport();
-
-  throw Error(`Cannot automatically detect which transport to use. You must specify a transport in your top-level app:
-
-    ---
-    import { createBunTransport } from '@aklinker1/zeta/transports/bun-transport';
-
-    const app = createApp({
-      transport: createBunTransport(),
-    })
-
-    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")
-  );
-}