Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

node_modules/astro/dist/core/render-context.js

@@ -0,0 +1,468 @@
+import { deserializeActionResult } from "../actions/runtime/virtual/shared.js";
+import { createCallAction, createGetActionResult, hasActionPayload } from "../actions/utils.js";
+import {
+  computeCurrentLocale,
+  computePreferredLocale,
+  computePreferredLocaleList
+} from "../i18n/utils.js";
+import { renderEndpoint } from "../runtime/server/endpoint.js";
+import { renderPage } from "../runtime/server/index.js";
+import {
+  ASTRO_VERSION,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  REWRITE_DIRECTIVE_HEADER_VALUE,
+  ROUTE_TYPE_HEADER,
+  clientAddressSymbol,
+  clientLocalsSymbol,
+  responseSentSymbol
+} from "./constants.js";
+import { AstroCookies, attachCookiesToResponse } from "./cookies/index.js";
+import { getCookiesFromResponse } from "./cookies/response.js";
+import { AstroError, AstroErrorData } from "./errors/index.js";
+import { callMiddleware } from "./middleware/callMiddleware.js";
+import { sequence } from "./middleware/index.js";
+import { renderRedirect } from "./redirects/render.js";
+import { Slots, getParams, getProps } from "./render/index.js";
+import { isRoute404or500 } from "./routing/match.js";
+import { copyRequest, setOriginPathname } from "./routing/rewrite.js";
+const apiContextRoutesSymbol = Symbol.for("context.routes");
+class RenderContext {
+  constructor(pipeline, locals, middleware, pathname, request, routeData, status, cookies = new AstroCookies(request), params = getParams(routeData, pathname), url = new URL(request.url), props = {}, partial = void 0) {
+    this.pipeline = pipeline;
+    this.locals = locals;
+    this.middleware = middleware;
+    this.pathname = pathname;
+    this.request = request;
+    this.routeData = routeData;
+    this.status = status;
+    this.cookies = cookies;
+    this.params = params;
+    this.url = url;
+    this.props = props;
+    this.partial = partial;
+  }
+  /**
+   * A flag that tells the render content if the rewriting was triggered
+   */
+  isRewriting = false;
+  /**
+   * A safety net in case of loops
+   */
+  counter = 0;
+  static async create({
+    locals = {},
+    middleware,
+    pathname,
+    pipeline,
+    request,
+    routeData,
+    status = 200,
+    props,
+    partial = void 0
+  }) {
+    const pipelineMiddleware = await pipeline.getMiddleware();
+    setOriginPathname(request, pathname);
+    return new RenderContext(
+      pipeline,
+      locals,
+      sequence(...pipeline.internalMiddleware, middleware ?? pipelineMiddleware),
+      pathname,
+      request,
+      routeData,
+      status,
+      void 0,
+      void 0,
+      void 0,
+      props,
+      partial
+    );
+  }
+  /**
+   * The main function of the RenderContext.
+   *
+   * Use this function to render any route known to Astro.
+   * It attempts to render a route. A route can be a:
+   *
+   * - page
+   * - redirect
+   * - endpoint
+   * - fallback
+   */
+  async render(componentInstance, slots = {}) {
+    const { cookies, middleware, pipeline } = this;
+    const { logger, serverLike, streaming } = pipeline;
+    const isPrerendered = !serverLike || this.routeData.prerender;
+    const props = Object.keys(this.props).length > 0 ? this.props : await getProps({
+      mod: componentInstance,
+      routeData: this.routeData,
+      routeCache: this.pipeline.routeCache,
+      pathname: this.pathname,
+      logger,
+      serverLike
+    });
+    const apiContext = this.createAPIContext(props, isPrerendered);
+    this.counter++;
+    if (this.counter === 4) {
+      return new Response("Loop Detected", {
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/508
+        status: 508,
+        statusText: "Astro detected a loop where you tried to call the rewriting logic more than four times."
+      });
+    }
+    const lastNext = async (ctx, payload) => {
+      if (payload) {
+        pipeline.logger.debug("router", "Called rewriting to:", payload);
+        const {
+          routeData,
+          componentInstance: newComponent,
+          pathname,
+          newUrl
+        } = await pipeline.tryRewrite(payload, this.request);
+        this.routeData = routeData;
+        componentInstance = newComponent;
+        if (payload instanceof Request) {
+          this.request = payload;
+        } else {
+          this.request = copyRequest(newUrl, this.request);
+        }
+        this.isRewriting = true;
+        this.url = new URL(this.request.url);
+        this.cookies = new AstroCookies(this.request);
+        this.params = getParams(routeData, pathname);
+        this.pathname = pathname;
+        this.status = 200;
+      }
+      let response2;
+      switch (this.routeData.type) {
+        case "endpoint": {
+          response2 = await renderEndpoint(componentInstance, ctx, serverLike, logger);
+          break;
+        }
+        case "redirect":
+          return renderRedirect(this);
+        case "page": {
+          const result = await this.createResult(componentInstance);
+          try {
+            response2 = await renderPage(
+              result,
+              componentInstance?.default,
+              props,
+              slots,
+              streaming,
+              this.routeData
+            );
+          } catch (e) {
+            result.cancelled = true;
+            throw e;
+          }
+          response2.headers.set(ROUTE_TYPE_HEADER, "page");
+          if (this.routeData.route === "/404" || this.routeData.route === "/500") {
+            response2.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
+          }
+          if (this.isRewriting) {
+            response2.headers.set(REWRITE_DIRECTIVE_HEADER_KEY, REWRITE_DIRECTIVE_HEADER_VALUE);
+          }
+          break;
+        }
+        case "fallback": {
+          return new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } });
+        }
+      }
+      const responseCookies = getCookiesFromResponse(response2);
+      if (responseCookies) {
+        cookies.merge(responseCookies);
+      }
+      return response2;
+    };
+    const response = await callMiddleware(middleware, apiContext, lastNext);
+    if (response.headers.get(ROUTE_TYPE_HEADER)) {
+      response.headers.delete(ROUTE_TYPE_HEADER);
+    }
+    attachCookiesToResponse(response, cookies);
+    return response;
+  }
+  createAPIContext(props, isPrerendered) {
+    const context = this.createActionAPIContext();
+    const redirect = (path, status = 302) => new Response(null, { status, headers: { Location: path } });
+    Reflect.set(context, apiContextRoutesSymbol, this.pipeline);
+    return Object.assign(context, {
+      props,
+      redirect,
+      getActionResult: createGetActionResult(context.locals),
+      callAction: createCallAction(context),
+      // Used internally by Actions middleware.
+      // TODO: discuss exposing this information from APIContext.
+      // middleware runs on prerendered routes in the dev server,
+      // so this is useful information to have.
+      _isPrerendered: isPrerendered
+    });
+  }
+  async #executeRewrite(reroutePayload) {
+    this.pipeline.logger.debug("router", "Calling rewrite: ", reroutePayload);
+    const { routeData, componentInstance, newUrl, pathname } = await this.pipeline.tryRewrite(
+      reroutePayload,
+      this.request
+    );
+    this.routeData = routeData;
+    if (reroutePayload instanceof Request) {
+      this.request = reroutePayload;
+    } else {
+      this.request = copyRequest(newUrl, this.request);
+    }
+    this.url = new URL(this.request.url);
+    this.cookies = new AstroCookies(this.request);
+    this.params = getParams(routeData, pathname);
+    this.pathname = pathname;
+    this.isRewriting = true;
+    this.status = 200;
+    return await this.render(componentInstance);
+  }
+  createActionAPIContext() {
+    const renderContext = this;
+    const { cookies, params, pipeline, url } = this;
+    const generator = `Astro v${ASTRO_VERSION}`;
+    const rewrite = async (reroutePayload) => {
+      return await this.#executeRewrite(reroutePayload);
+    };
+    return {
+      cookies,
+      get clientAddress() {
+        return renderContext.clientAddress();
+      },
+      get currentLocale() {
+        return renderContext.computeCurrentLocale();
+      },
+      generator,
+      get locals() {
+        return renderContext.locals;
+      },
+      // TODO(breaking): disallow replacing the locals object
+      set locals(val) {
+        if (typeof val !== "object") {
+          throw new AstroError(AstroErrorData.LocalsNotAnObject);
+        } else {
+          renderContext.locals = val;
+          Reflect.set(this.request, clientLocalsSymbol, val);
+        }
+      },
+      params,
+      get preferredLocale() {
+        return renderContext.computePreferredLocale();
+      },
+      get preferredLocaleList() {
+        return renderContext.computePreferredLocaleList();
+      },
+      rewrite,
+      request: this.request,
+      site: pipeline.site,
+      url
+    };
+  }
+  async createResult(mod) {
+    const { cookies, pathname, pipeline, routeData, status } = this;
+    const { clientDirectives, inlinedScripts, compressHTML, manifest, renderers, resolve } = pipeline;
+    const { links, scripts, styles } = await pipeline.headElements(routeData);
+    const componentMetadata = await pipeline.componentMetadata(routeData) ?? manifest.componentMetadata;
+    const headers = new Headers({ "Content-Type": "text/html" });
+    const partial = typeof this.partial === "boolean" ? this.partial : Boolean(mod.partial);
+    const response = {
+      status,
+      statusText: "OK",
+      get headers() {
+        return headers;
+      },
+      // Disallow `Astro.response.headers = new Headers`
+      set headers(_) {
+        throw new AstroError(AstroErrorData.AstroResponseHeadersReassigned);
+      }
+    };
+    const actionResult = hasActionPayload(this.locals) ? deserializeActionResult(this.locals._actionPayload.actionResult) : void 0;
+    const result = {
+      base: manifest.base,
+      cancelled: false,
+      clientDirectives,
+      inlinedScripts,
+      componentMetadata,
+      compressHTML,
+      cookies,
+      /** This function returns the `Astro` faux-global */
+      createAstro: (astroGlobal, props, slots) => this.createAstro(result, astroGlobal, props, slots),
+      links,
+      params: this.params,
+      partial,
+      pathname,
+      renderers,
+      resolve,
+      response,
+      request: this.request,
+      scripts,
+      styles,
+      actionResult,
+      serverIslandNameMap: manifest.serverIslandNameMap ?? /* @__PURE__ */ new Map(),
+      key: manifest.key,
+      trailingSlash: manifest.trailingSlash,
+      _metadata: {
+        hasHydrationScript: false,
+        rendererSpecificHydrationScripts: /* @__PURE__ */ new Set(),
+        hasRenderedHead: false,
+        renderedScripts: /* @__PURE__ */ new Set(),
+        hasDirectives: /* @__PURE__ */ new Set(),
+        headInTree: false,
+        extraHead: [],
+        propagators: /* @__PURE__ */ new Set()
+      }
+    };
+    return result;
+  }
+  #astroPagePartial;
+  /**
+   * The Astro global is sourced in 3 different phases:
+   * - **Static**: `.generator` and `.glob` is printed by the compiler, instantiated once per process per astro file
+   * - **Page-level**: `.request`, `.cookies`, `.locals` etc. These remain the same for the duration of the request.
+   * - **Component-level**: `.props`, `.slots`, and `.self` are unique to each _use_ of each component.
+   *
+   * The page level partial is used as the prototype of the user-visible `Astro` global object, which is instantiated once per use of a component.
+   */
+  createAstro(result, astroStaticPartial, props, slotValues) {
+    let astroPagePartial;
+    if (this.isRewriting) {
+      astroPagePartial = this.#astroPagePartial = this.createAstroPagePartial(
+        result,
+        astroStaticPartial
+      );
+    } else {
+      astroPagePartial = this.#astroPagePartial ??= this.createAstroPagePartial(
+        result,
+        astroStaticPartial
+      );
+    }
+    const astroComponentPartial = { props, self: null };
+    const Astro = Object.assign(
+      Object.create(astroPagePartial),
+      astroComponentPartial
+    );
+    let _slots;
+    Object.defineProperty(Astro, "slots", {
+      get: () => {
+        if (!_slots) {
+          _slots = new Slots(
+            result,
+            slotValues,
+            this.pipeline.logger
+          );
+        }
+        return _slots;
+      }
+    });
+    return Astro;
+  }
+  createAstroPagePartial(result, astroStaticPartial) {
+    const renderContext = this;
+    const { cookies, locals, params, pipeline, url } = this;
+    const { response } = result;
+    const redirect = (path, status = 302) => {
+      if (this.request[responseSentSymbol]) {
+        throw new AstroError({
+          ...AstroErrorData.ResponseSentError
+        });
+      }
+      return new Response(null, { status, headers: { Location: path } });
+    };
+    const rewrite = async (reroutePayload) => {
+      return await this.#executeRewrite(reroutePayload);
+    };
+    return {
+      generator: astroStaticPartial.generator,
+      glob: astroStaticPartial.glob,
+      cookies,
+      get clientAddress() {
+        return renderContext.clientAddress();
+      },
+      get currentLocale() {
+        return renderContext.computeCurrentLocale();
+      },
+      params,
+      get preferredLocale() {
+        return renderContext.computePreferredLocale();
+      },
+      get preferredLocaleList() {
+        return renderContext.computePreferredLocaleList();
+      },
+      locals,
+      redirect,
+      rewrite,
+      request: this.request,
+      response,
+      site: pipeline.site,
+      getActionResult: createGetActionResult(locals),
+      get callAction() {
+        return createCallAction(this);
+      },
+      url
+    };
+  }
+  clientAddress() {
+    const { pipeline, request } = this;
+    if (clientAddressSymbol in request) {
+      return Reflect.get(request, clientAddressSymbol);
+    }
+    if (pipeline.serverLike) {
+      if (request.body === null) {
+        throw new AstroError(AstroErrorData.PrerenderClientAddressNotAvailable);
+      }
+      if (pipeline.adapterName) {
+        throw new AstroError({
+          ...AstroErrorData.ClientAddressNotAvailable,
+          message: AstroErrorData.ClientAddressNotAvailable.message(pipeline.adapterName)
+        });
+      }
+    }
+    throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+  }
+  /**
+   * API Context may be created multiple times per request, i18n data needs to be computed only once.
+   * So, it is computed and saved here on creation of the first APIContext and reused for later ones.
+   */
+  #currentLocale;
+  computeCurrentLocale() {
+    const {
+      url,
+      pipeline: { i18n },
+      routeData
+    } = this;
+    if (!i18n) return;
+    const { defaultLocale, locales, strategy } = i18n;
+    const fallbackTo = strategy === "pathname-prefix-other-locales" || strategy === "domains-prefix-other-locales" ? defaultLocale : void 0;
+    if (this.#currentLocale) {
+      return this.#currentLocale;
+    }
+    let computedLocale;
+    const pathname = routeData.pathname && !isRoute404or500(routeData) ? routeData.pathname : url.pathname;
+    computedLocale = computeCurrentLocale(pathname, locales, defaultLocale);
+    this.#currentLocale = computedLocale ?? fallbackTo;
+    return this.#currentLocale;
+  }
+  #preferredLocale;
+  computePreferredLocale() {
+    const {
+      pipeline: { i18n },
+      request
+    } = this;
+    if (!i18n) return;
+    return this.#preferredLocale ??= computePreferredLocale(request, i18n.locales);
+  }
+  #preferredLocaleList;
+  computePreferredLocaleList() {
+    const {
+      pipeline: { i18n },
+      request
+    } = this;
+    if (!i18n) return;
+    return this.#preferredLocaleList ??= computePreferredLocaleList(request, i18n.locales);
+  }
+}
+export {
+  RenderContext,
+  apiContextRoutesSymbol
+};