astro 4.1.2 → 4.2.0

package/dist/core/app/index.js

@@ -19,9 +19,10 @@ import {
 import { matchRoute } from "../routing/match.js";
 import { EndpointNotFoundError, SSRRoutePipeline } from "./ssrPipeline.js";
 import { deserializeManifest } from "./common.js";
-const clientLocalsSymbol = Symbol.for("astro.locals");
+const localsSymbol = Symbol.for("astro.locals");
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
 const responseSentSymbol = Symbol.for("astro.responseSent");
-const STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
+const REROUTABLE_STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
 class App {
   /**
    * The current environment of the application
@@ -115,7 +116,15 @@ class App {
   async render(request, routeDataOrOptions, maybeLocals) {
     let routeData;
     let locals;
-    if (routeDataOrOptions && ("routeData" in routeDataOrOptions || "locals" in routeDataOrOptions)) {
+    let clientAddress;
+    let addCookieHeader;
+    if (routeDataOrOptions && ("addCookieHeader" in routeDataOrOptions || "clientAddress" in routeDataOrOptions || "locals" in routeDataOrOptions || "routeData" in routeDataOrOptions)) {
+      if ("addCookieHeader" in routeDataOrOptions) {
+        addCookieHeader = routeDataOrOptions.addCookieHeader;
+      }
+      if ("clientAddress" in routeDataOrOptions) {
+        clientAddress = routeDataOrOptions.clientAddress;
+      }
       if ("routeData" in routeDataOrOptions) {
         routeData = routeDataOrOptions.routeData;
       }
@@ -129,6 +138,12 @@ class App {
         this.#logRenderOptionsDeprecationWarning();
       }
     }
+    if (locals) {
+      Reflect.set(request, localsSymbol, locals);
+    }
+    if (clientAddress) {
+      Reflect.set(request, clientAddressSymbol, clientAddress);
+    }
     if (request.url !== collapseDuplicateSlashes(request.url)) {
       request = new Request(collapseDuplicateSlashes(request.url), request);
     }
@@ -138,7 +153,6 @@ class App {
     if (!routeData) {
       return this.#renderError(request, { status: 404 });
     }
-    Reflect.set(request, clientLocalsSymbol, locals ?? {});
     const pathname = this.#getPathnameFromRequest(request);
     const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
     const mod = await this.#getModuleForRoute(routeData);
@@ -153,7 +167,7 @@ class App {
     );
     let response;
     try {
-      let i18nMiddleware = createI18nMiddleware(
+      const i18nMiddleware = createI18nMiddleware(
         this.#manifest.i18n,
         this.#manifest.base,
         this.#manifest.trailingSlash
@@ -180,15 +194,19 @@ class App {
       }
     }
     if (routeData.type === "page" || routeData.type === "redirect") {
-      if (STATUS_CODES.has(response.status)) {
+      if (REROUTABLE_STATUS_CODES.has(response.status)) {
         return this.#renderError(request, {
           response,
           status: response.status
         });
       }
-      Reflect.set(response, responseSentSymbol, true);
-      return response;
     }
+    if (addCookieHeader) {
+      for (const setCookieHeaderValue of App.getSetCookieFromResponse(response)) {
+        response.headers.append("set-cookie", setCookieHeaderValue);
+      }
+    }
+    Reflect.set(response, responseSentSymbol, true);
     return response;
   }
   #logRenderOptionsDeprecationWarning() {
@@ -203,6 +221,18 @@ class App {
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
+  /**
+   * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
+   * For example,
+   * ```ts
+   * for (const cookie_ of App.getSetCookieFromResponse(response)) {
+   *     const cookie: string = cookie_
+   * }
+   * ```
+   * @param response The response to read cookies from.
+   * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
+   */
+  static getSetCookieFromResponse = getSetCookiesFromResponse;
   /**
    * Creates the render context of the current route
    */

package/dist/core/app/node.d.ts

@@ -1,25 +1,57 @@
 /// <reference types="node" resolution-mode="require"/>
+import { App } from './index.js';
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { RouteData } from '../../@types/astro.js';
 import type { RenderOptions } from './index.js';
 import type { SSRManifest } from './types.js';
-import { IncomingMessage } from 'node:http';
-import { App } from './index.js';
 export { apply as applyPolyfills } from '../polyfill.js';
-declare class NodeIncomingMessage extends IncomingMessage {
-    /**
-     * Allow the request body to be explicitly overridden. For example, this
-     * is used by the Express JSON middleware.
-     */
+/**
+ * Allow the request body to be explicitly overridden. For example, this
+ * is used by the Express JSON middleware.
+ */
+interface NodeRequest extends IncomingMessage {
     body?: unknown;
 }
 export declare class NodeApp extends App {
-    match(req: NodeIncomingMessage | Request): RouteData | undefined;
-    render(request: NodeIncomingMessage | Request, options?: RenderOptions): Promise<Response>;
+    match(req: NodeRequest | Request): RouteData | undefined;
+    render(request: NodeRequest | Request, options?: RenderOptions): Promise<Response>;
     /**
      * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
      * See https://github.com/withastro/astro/pull/9199 for more information.
      */
-    render(request: NodeIncomingMessage | Request, routeData?: RouteData, locals?: object): Promise<Response>;
+    render(request: NodeRequest | Request, routeData?: RouteData, locals?: object): Promise<Response>;
+    /**
+     * Converts a NodeJS IncomingMessage into a web standard Request.
+     * ```js
+     * import { NodeApp } from 'astro/app/node';
+     * import { createServer } from 'node:http';
+     *
+     * const server = createServer(async (req, res) => {
+     *     const request = NodeApp.createRequest(req);
+     *     const response = await app.render(request);
+     *     await NodeApp.writeResponse(response, res);
+     * })
+     * ```
+     */
+    static createRequest(req: NodeRequest, { skipBody }?: {
+        skipBody?: boolean | undefined;
+    }): Request;
+    /**
+     * Streams a web-standard Response into a NodeJS Server Response.
+     * ```js
+     * import { NodeApp } from 'astro/app/node';
+     * import { createServer } from 'node:http';
+     *
+     * const server = createServer(async (req, res) => {
+     *     const request = NodeApp.createRequest(req);
+     *     const response = await app.render(request);
+     *     await NodeApp.writeResponse(response, res);
+     * })
+     * ```
+     * @param source WhatWG Response
+     * @param destination NodeJS ServerResponse
+     */
+    static writeResponse(source: Response, destination: ServerResponse): Promise<void>;
 }
 export declare function loadManifest(rootFolder: URL): Promise<SSRManifest>;
 export declare function loadApp(rootFolder: URL): Promise<NodeApp>;

package/dist/core/app/node.js

@@ -1,30 +1,95 @@
-import * as fs from "node:fs";
-import { IncomingMessage } from "node:http";
-import { TLSSocket } from "node:tls";
-import { deserializeManifest } from "./common.js";
+import fs from "node:fs";
 import { App } from "./index.js";
+import { deserializeManifest } from "./common.js";
+import { createOutgoingHttpHeaders } from "./createOutgoingHttpHeaders.js";
 import { apply } from "../polyfill.js";
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
-function createRequestFromNodeRequest(req, options) {
-  const protocol = req.socket instanceof TLSSocket || req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
-  const hostname = req.headers.host || req.headers[":authority"];
-  const url = `${protocol}://${hostname}${req.url}`;
-  const headers = makeRequestHeaders(req);
-  const method = req.method || "GET";
-  let bodyProps = {};
-  const bodyAllowed = method !== "HEAD" && method !== "GET" && !options?.emptyBody;
-  if (bodyAllowed) {
-    bodyProps = makeRequestBody(req);
+class NodeApp extends App {
+  match(req) {
+    if (!(req instanceof Request)) {
+      req = NodeApp.createRequest(req, {
+        skipBody: true
+      });
+    }
+    return super.match(req);
+  }
+  render(req, routeDataOrOptions, maybeLocals) {
+    if (!(req instanceof Request)) {
+      req = NodeApp.createRequest(req);
+    }
+    return super.render(req, routeDataOrOptions, maybeLocals);
   }
-  const request = new Request(url, {
-    method,
-    headers,
-    ...bodyProps
-  });
-  if (req.socket?.remoteAddress) {
-    Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+  /**
+   * Converts a NodeJS IncomingMessage into a web standard Request.
+   * ```js
+   * import { NodeApp } from 'astro/app/node';
+   * import { createServer } from 'node:http';
+   *
+   * const server = createServer(async (req, res) => {
+   *     const request = NodeApp.createRequest(req);
+   *     const response = await app.render(request);
+   *     await NodeApp.writeResponse(response, res);
+   * })
+   * ```
+   */
+  static createRequest(req, { skipBody = false } = {}) {
+    const protocol = req.headers["x-forwarded-proto"] ?? ("encrypted" in req.socket && req.socket.encrypted ? "https" : "http");
+    const hostname = req.headers.host || req.headers[":authority"];
+    const url = `${protocol}://${hostname}${req.url}`;
+    const options = {
+      method: req.method || "GET",
+      headers: makeRequestHeaders(req)
+    };
+    const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
+    if (bodyAllowed) {
+      Object.assign(options, makeRequestBody(req));
+    }
+    const request = new Request(url, options);
+    if (req.socket?.remoteAddress) {
+      Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+    }
+    return request;
+  }
+  /**
+   * Streams a web-standard Response into a NodeJS Server Response.
+   * ```js
+   * import { NodeApp } from 'astro/app/node';
+   * import { createServer } from 'node:http';
+   *
+   * const server = createServer(async (req, res) => {
+   *     const request = NodeApp.createRequest(req);
+   *     const response = await app.render(request);
+   *     await NodeApp.writeResponse(response, res);
+   * })
+   * ```
+   * @param source WhatWG Response
+   * @param destination NodeJS ServerResponse
+   */
+  static async writeResponse(source, destination) {
+    const { status, headers, body } = source;
+    destination.writeHead(status, createOutgoingHttpHeaders(headers));
+    if (body) {
+      try {
+        const reader = body.getReader();
+        destination.on("close", () => {
+          reader.cancel().catch((err) => {
+            console.error(
+              `There was an uncaught error in the middle of the stream while rendering ${destination.req.url}.`,
+              err
+            );
+          });
+        });
+        let result = await reader.read();
+        while (!result.done) {
+          destination.write(result.value);
+          result = await reader.read();
+        }
+      } catch {
+        destination.write("Internal server error");
+      }
+    }
+    destination.end();
   }
-  return request;
 }
 function makeRequestHeaders(req) {
   const headers = new Headers();
@@ -65,33 +130,9 @@ function asyncIterableToBodyProps(iterable) {
     // The duplex property is required when using a ReadableStream or async
     // iterable for the body. The type definitions do not include the duplex
     // property because they are not up-to-date.
-    // @ts-expect-error
     duplex: "half"
   };
 }
-class NodeIncomingMessage extends IncomingMessage {
-  /**
-   * Allow the request body to be explicitly overridden. For example, this
-   * is used by the Express JSON middleware.
-   */
-  body;
-}
-class NodeApp extends App {
-  match(req) {
-    if (!(req instanceof Request)) {
-      req = createRequestFromNodeRequest(req, {
-        emptyBody: true
-      });
-    }
-    return super.match(req);
-  }
-  render(req, routeDataOrOptions, maybeLocals) {
-    if (!(req instanceof Request)) {
-      req = createRequestFromNodeRequest(req);
-    }
-    return super.render(req, routeDataOrOptions, maybeLocals);
-  }
-}
 async function loadManifest(rootFolder) {
   const manifestFile = new URL("./manifest.json", rootFolder);
   const rawManifest = await fs.promises.readFile(manifestFile, "utf-8");

package/dist/core/app/types.d.ts

@@ -1,5 +1,6 @@
 import type { Locales, RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro.js';
 import type { SinglePageBuiltModule } from '../build/types.js';
+import type { RoutingStrategies } from '../config/schema.js';
 export type ComponentPath = string;
 export type StylesheetAsset = {
     type: 'inline';
@@ -47,7 +48,7 @@ export type SSRManifest = {
 };
 export type SSRManifestI18n = {
     fallback?: Record<string, string>;
-    routing?: 'prefix-always' | 'prefix-other-locales';
+    routing?: RoutingStrategies;
     locales: Locales;
     defaultLocale: string;
 };