@stacksjs/bun-router 0.0.22 → 0.0.24

package/dist/cli.js

@@ -2047,7 +2047,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version = "0.0.22";
+var version = "0.0.24";
 
 // src/cli/middleware.ts
 import fs2 from "fs/promises";

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export * as Errors from './errors';
 export * from './middleware';
 export { enableRequestContext, getCurrentRequest, request, runWithRequest, setCurrentRequest } from './request/context';
 export * from './session';
+export * from './response/compression';
 export * from './response/response-factory';
 export * from './router';
 export { MiddlewareGroupRegistry, middlewareGroups } from './router/middleware-groups';

package/dist/index.js

@@ -2047,6 +2047,97 @@ function request() {
   }
   return req;
 }
+// src/response/compression.ts
+var DEFAULT_COMPRESSION = {
+  enabled: true,
+  level: 6,
+  threshold: 1024
+};
+function isCompressible(contentType) {
+  if (!contentType)
+    return false;
+  const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (type.startsWith("text/"))
+    return true;
+  return [
+    "application/json",
+    "application/ld+json",
+    "application/manifest+json",
+    "application/javascript",
+    "application/x-javascript",
+    "application/xml",
+    "application/xhtml+xml",
+    "application/rss+xml",
+    "application/atom+xml",
+    "application/graphql",
+    "application/x-ndjson",
+    "image/svg+xml"
+  ].includes(type);
+}
+function negotiateEncoding(header) {
+  if (!header)
+    return null;
+  const offers = new Map;
+  for (const part of header.split(",")) {
+    const [name = "", ...parameters] = part.trim().split(";");
+    const quality = parameters.map((parameter) => /^\s*q=([\d.]+)\s*$/i.exec(parameter)).find(Boolean);
+    offers.set(name.trim().toLowerCase(), quality ? Number(quality[1]) : 1);
+  }
+  const wanted = (name) => (offers.get(name) ?? offers.get("*") ?? 0) > 0;
+  if (wanted("gzip"))
+    return "gzip";
+  if (wanted("deflate"))
+    return "deflate";
+  return null;
+}
+function shouldCompress(response, encoding, threshold) {
+  if (!encoding)
+    return false;
+  if (response.status === 204 || response.status === 304 || response.status === 206)
+    return false;
+  if (response.headers.has("content-encoding"))
+    return false;
+  if (!isCompressible(response.headers.get("content-type")))
+    return false;
+  const length = Number(response.headers.get("content-length") ?? Number.NaN);
+  if (!Number.isFinite(length))
+    return false;
+  return length >= threshold;
+}
+async function compressResponse(response, request2, options = {}) {
+  const settings = { ...DEFAULT_COMPRESSION, ...options };
+  if (!settings.enabled)
+    return response;
+  const encoding = negotiateEncoding(request2.headers.get("accept-encoding"));
+  if (!shouldCompress(response, encoding, settings.threshold)) {
+    if (isCompressible(response.headers.get("content-type")) && !response.headers.has("content-encoding"))
+      appendVary(response.headers, "Accept-Encoding");
+    return response;
+  }
+  const body = new Uint8Array(await response.arrayBuffer());
+  const compressed = encoding === "gzip" ? Bun.gzipSync(body, { level: settings.level }) : Bun.deflateSync(body, { level: settings.level });
+  if (compressed.byteLength >= body.byteLength) {
+    const headers2 = new Headers(response.headers);
+    appendVary(headers2, "Accept-Encoding");
+    return new Response(body, { status: response.status, statusText: response.statusText, headers: headers2 });
+  }
+  const headers = new Headers(response.headers);
+  headers.set("Content-Encoding", encoding);
+  headers.set("Content-Length", String(compressed.byteLength));
+  appendVary(headers, "Accept-Encoding");
+  return new Response(compressed, { status: response.status, statusText: response.statusText, headers });
+}
+function appendVary(headers, value) {
+  const existing = headers.get("vary");
+  if (!existing) {
+    headers.set("Vary", value);
+    return;
+  }
+  const parts = existing.split(",").map((part) => part.trim().toLowerCase());
+  if (parts.includes("*") || parts.includes(value.toLowerCase()))
+    return;
+  headers.set("Vary", `${existing}, ${value}`);
+}
 // src/response/response-factory.ts
 var response = {
   json: (data, options = {}) => {
@@ -3074,7 +3165,19 @@ function findPrebuiltView(stxFilePath, viewsDir) {
   }
   return null;
 }
-async function renderStxFile(filePath, viewsDir, data, routingConfig) {
+function parseCookies(header) {
+  const jar = {};
+  for (const part of String(header ?? "").split(";")) {
+    const cut = part.indexOf("=");
+    if (cut < 0)
+      continue;
+    try {
+      jar[part.slice(0, cut).trim()] = decodeURIComponent(part.slice(cut + 1).trim());
+    } catch {}
+  }
+  return jar;
+}
+async function renderStxFile(filePath, viewsDir, data, routingConfig, request2) {
   const stxModule = "@stacksjs/stx";
   const stx = await import(stxModule);
   if (!stx.processDirectives || !stx.extractVariables) {
@@ -3085,11 +3188,42 @@ async function renderStxFile(filePath, viewsDir, data, routingConfig) {
   const scriptContent = scriptMatch ? scriptMatch[1] : "";
   let templateContent = scriptMatch ? content.replace(/<script\s+server\s*>[\s\S]*?<\/script>/i, "") : content;
   templateContent = templateContent.replace(/<script\s+client\s*>/gi, "<script>");
+  const asked = { status: 200, headers: {} };
+  const headerBag = data.headers ?? {};
+  const cookieHeader = String(headerBag.cookie ?? headerBag.Cookie ?? "");
+  const requestUrl = String(data.url ?? "");
+  const search = requestUrl.includes("?") ? requestUrl.slice(requestUrl.indexOf("?")) : "";
+  const serveContext = {
+    url: requestUrl,
+    path: String(data.path ?? ""),
+    search,
+    host: String(headerBag.host ?? ""),
+    cookieHeader,
+    cookies: parseCookies(cookieHeader),
+    ip: "",
+    locale: null,
+    params: data.params ?? {},
+    method: String(data.method ?? "GET"),
+    request: request2
+  };
   const context = {
     __filename: filePath,
     __dirname: dirname(filePath),
     props: data,
-    ...data
+    ...data,
+    __stxServeContext: serveContext,
+    setResponseStatus: (status) => {
+      if (Number.isInteger(status) && status >= 100 && status <= 599)
+        asked.status = status;
+    },
+    notFound: (status = 404) => {
+      asked.status = Number.isInteger(status) && status >= 400 && status <= 599 ? status : 404;
+    },
+    setResponseHeader: (name, value) => {
+      if (name)
+        asked.headers[String(name)] = String(value);
+    },
+    definePageMeta: () => {}
   };
   if (scriptContent) {
     await stx.extractVariables(scriptContent, context, filePath);
@@ -3103,7 +3237,14 @@ async function renderStxFile(filePath, viewsDir, data, routingConfig) {
     layoutsDir: resolvedLayoutsDir,
     partialsDir: resolvedPartialsDir
   };
-  return stx.processDirectives(templateContent, context, filePath, config2, new Set);
+  const html = await stx.processDirectives(templateContent, context, filePath, config2, new Set);
+  const recordedStatus = Number(context.__stxResponseStatus);
+  const recordedHeaders = context.__stxResponseHeaders;
+  return {
+    html,
+    status: Number.isInteger(recordedStatus) && recordedStatus >= 100 && recordedStatus <= 599 ? recordedStatus : asked.status,
+    headers: { ...asked.headers, ...recordedHeaders ?? {} }
+  };
 }
 function createViewHandler(filePath, viewsDir, config2, queryPreservationConfig) {
   return async (req) => {
@@ -3133,11 +3274,11 @@ function createViewHandler(filePath, viewsDir, config2, queryPreservationConfig)
         });
       }
       if (filePath.endsWith(".stx")) {
-        let html = await renderStxFile(filePath, viewsDir, data, config2);
-        html = applyQueryPreservation(html);
+        const rendered = await renderStxFile(filePath, viewsDir, data, config2, req);
+        const html = applyQueryPreservation(rendered.html);
         return new Response(html, {
-          status: 200,
-          headers: { "Content-Type": "text/html; charset=utf-8" }
+          status: rendered.status,
+          headers: { "Content-Type": "text/html; charset=utf-8", ...rendered.headers }
         });
       }
       let content = await Bun.file(filePath).text();
@@ -9513,7 +9654,8 @@ function registerServerHandling(RouterClass) {
     handleRequest: {
       async value(req) {
         const self = this;
-        return runWithRequest(req, () => self.handleRequestImpl(req));
+        const response2 = await runWithRequest(req, () => self.handleRequestImpl(req));
+        return await compressResponse(response2, req, self.config?.compression ?? {});
       },
       writable: true,
       configurable: true
@@ -13614,6 +13756,7 @@ export {
   spyOnMiddleware,
   singleFileUpload,
   signRequest,
+  shouldCompress,
   setCurrentRequest,
   setContainer,
   session,
@@ -13645,6 +13788,7 @@ export {
   parseThrottleString,
   oauth2Auth,
   normalizePath,
+  negotiateEncoding,
   multipleFileUpload,
   modelMocks,
   mockMiddleware,
@@ -13656,6 +13800,7 @@ export {
   jsonBody,
   joinPaths,
   isRouteHandler,
+  isCompressible,
   isActionClass,
   inputValidation,
   injectQueryPreservationScript,
@@ -13713,6 +13858,7 @@ export {
   contentSecurityPolicy,
   constraintHelpers,
   config,
+  compressResponse,
   clearNamedRoutes,
   buildUrlWithPreservedParams,
   benchmarkTests,
@@ -13723,6 +13869,7 @@ export {
   authHelpers,
   auth,
   applyRequestEnhancements,
+  appendVary,
   apiKeyAuth,
   WebSocketTester,
   Validator,
@@ -13804,6 +13951,7 @@ export {
   DefaultServiceProviderManager,
   DatabaseSessionStore,
   DatabaseRules,
+  DEFAULT_COMPRESSION,
   DDoSProtection,
   Csrf,
   Cors,

package/dist/response/compression.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Compressing what goes back, which nothing was doing.
+ *
+ * Static files have been served gzipped for a long time; every response a
+ * *route* produced went out whole. A server-rendered page is the shape that
+ * costs: the landing page of the application this was found in is 253 KB of
+ * HTML and compresses to about a tenth of that, on every request, for every
+ * visitor - and the same is true of any JSON list long enough to matter.
+ *
+ * Three rules, and the middle one is the important one:
+ *
+ * - **Only when the client asked.** `Accept-Encoding` decides, and `Vary` says
+ *   so, because a cache that hands a gzipped body to a client that did not ask
+ *   is a cache that breaks that client.
+ * - **Only when the length is known.** A response with no `Content-Length` is a
+ *   stream, and buffering one to compress it would turn a progressive render
+ *   into a wait - the diff manifest that streams a hundred files as they parse
+ *   would arrive all at once, at the end. Streams are left alone.
+ * - **Only when it is worth it.** Below a kilobyte the header costs more than
+ *   the saving, and already-compressed bytes (an image, a woff2, a zip) get
+ *   bigger rather than smaller.
+ */
+/** zlib's own range, so a level Bun would reject is a type error rather than a throw. */
+export type CompressionLevel = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export interface CompressionOptions {
+    /** Off turns the whole thing off, for a proxy that already compresses. */
+    enabled?: boolean;
+    /** zlib level. 6 is the usual balance; 9 costs noticeably more CPU for a few percent. */
+    level?: CompressionLevel;
+    /** Bodies below this many bytes are sent as they are. */
+    threshold?: number;
+}
+export declare const DEFAULT_COMPRESSION: Required<CompressionOptions>;
+/**
+ * Content types worth compressing.
+ *
+ * A prefix list rather than a regex over everything: `image/svg+xml` is text
+ * and compresses well, `image/png` is already compressed and grows. When in
+ * doubt the answer is no, because sending something slightly larger is a
+ * wasted CPU cycle and a wasted byte, while failing to compress is only a
+ * missed saving.
+ */
+export declare function isCompressible(contentType: string | null): boolean;
+/**
+ * The encoding to use, from what the client offered.
+ *
+ * gzip before deflate, and `q=0` respected - a client that says
+ * `gzip;q=0` means it, and sending gzip anyway is how you get an unreadable
+ * page in the one browser that asked.
+ *
+ * Brotli is not offered even though Bun can produce it: `Bun.gzipSync` is
+ * synchronous and brotli is not, and a compression step that awaits inside the
+ * response path is a different change from this one.
+ */
+export declare function negotiateEncoding(header: string | null): 'gzip' | 'deflate' | null;
+/** Whether this response should be compressed at all, and why not when it should not. */
+export declare function shouldCompress(response: Response, encoding: string | null, threshold: number): boolean;
+/**
+ * The response, compressed when that is the right thing to do.
+ *
+ * Returns the response it was given when it is not, so a caller can apply this
+ * unconditionally at the end of the pipeline.
+ */
+export declare function compressResponse(response: Response, request: Request, options?: CompressionOptions): Promise<Response>;
+/** Add to `Vary` without dropping what is already there. */
+export declare function appendVary(headers: Headers, value: string): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/bun-router",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "A fast, type-safe router for Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",