cloudcommerce 0.10.0 → 0.12.0

package/packages/storefront/dist/server/chunks/{astro.39f7f387.mjs → astro.7ac24846.mjs}

@@ -633,6 +633,90 @@ Expected \`true\` value but got \`${suffix}\`.`;
     code: 3030,
     message: "The response has already been sent to the browser and cannot be altered."
   },
+  /**
+   * @docs
+   * @description
+   * Thrown when the middleware does not return any data or call the `next` function.
+   *
+   * For example:
+   * ```ts
+   * import {defineMiddleware} from "astro/middleware";
+   * export const onRequest = defineMiddleware((context, _) => {
+   * 	// doesn't return anything or call `next`
+   * 	context.locals.someData = false;
+   * });
+   * ```
+   */
+  MiddlewareNoDataOrNextCalled: {
+    title: "The middleware didn't return a response or call `next`",
+    code: 3031,
+    message: "The middleware needs to either return a `Response` object or call the `next` function."
+  },
+  /**
+   * @docs
+   * @description
+   * Thrown in development mode when middleware returns something that is not a `Response` object.
+   *
+   * For example:
+   * ```ts
+   * import {defineMiddleware} from "astro/middleware";
+   * export const onRequest = defineMiddleware(() => {
+   *   return "string"
+   * });
+   * ```
+   */
+  MiddlewareNotAResponse: {
+    title: "The middleware returned something that is not a `Response` object",
+    code: 3032,
+    message: "Any data returned from middleware must be a valid `Response` object."
+  },
+  /**
+   * @docs
+   * @description
+   *
+   * Thrown in development mode when `locals` is overwritten with something that is not an object
+   *
+   * For example:
+   * ```ts
+   * import {defineMiddleware} from "astro/middleware";
+   * export const onRequest = defineMiddleware((context, next) => {
+   *   context.locals = 1541;
+   *   return next();
+   * });
+   * ```
+   */
+  LocalsNotAnObject: {
+    title: "Value assigned to `locals` is not accepted",
+    code: 3033,
+    message: "`locals` can only be assigned to an object. Other values like numbers, strings, etc. are not accepted.",
+    hint: "If you tried to remove some information from the `locals` object, try to use `delete` or set the property to `undefined`."
+  },
+  /**
+   * @docs
+   * @description
+   * Thrown in development mode when a user attempts to store something that is not serializable in `locals`.
+   *
+   * For example:
+   * ```ts
+   * import {defineMiddleware} from "astro/middleware";
+   * export const onRequest = defineMiddleware((context, next) => {
+   *   context.locals = {
+   *     foo() {
+   *       alert("Hello world!")
+   *     }
+   *   };
+   *   return next();
+   * });
+   * ```
+   */
+  LocalsNotSerializable: {
+    title: "`Astro.locals` is not serializable",
+    code: 3034,
+    message: (href) => {
+      return `The information stored in \`Astro.locals\` for the path "${href}" is not serializable.
+Make sure you store only serializable data.`;
+    }
+  },
   // No headings here, that way Vite errors are merged with Astro ones in the docs, which makes more sense to users.
   // Vite Errors - 4xxx
   /**
@@ -1226,7 +1310,7 @@ function createComponent(arg1, moduleId) {
   }
 }
 
-const ASTRO_VERSION = "2.3.0";
+const ASTRO_VERSION = "2.4.5";
 
 function createAstroGlobFn() {
   const globHandler = (importMetaGlobResult, globValue) => {
@@ -1260,7 +1344,7 @@ function getHandlerFromModule(mod, method) {
 }
 async function renderEndpoint(mod, context, ssr) {
   var _a;
-  const { request, params } = context;
+  const { request, params, locals } = context;
   const chosenMethod = (_a = request.method) == null ? void 0 : _a.toLowerCase();
   const handler = getHandlerFromModule(mod, chosenMethod);
   if (!ssr && ssr === false && chosenMethod && chosenMethod !== "get") {
@@ -1639,7 +1723,9 @@ const uniqueElements = (item, index, all) => {
 };
 function renderAllHeadContent(result) {
   result._metadata.hasRenderedHead = true;
-  const styles = Array.from(result.styles).filter(uniqueElements).map((style) => renderElement$1("style", style));
+  const styles = Array.from(result.styles).filter(uniqueElements).map(
+    (style) => style.props.rel === "stylesheet" ? renderElement$1("link", style) : renderElement$1("style", style)
+  );
   result.styles.clear();
   const scripts = Array.from(result.scripts).filter(uniqueElements).map((script, i) => {
     return renderElement$1("script", script, false);
@@ -2656,7 +2742,7 @@ If you're still stuck, please open an issue on GitHub or join us at https://astr
       if (isPage || (renderer == null ? void 0 : renderer.name) === "astro:jsx") {
         yield html;
       } else if (html && html.length > 0) {
-        yield markHTMLString(html.replace(/\<\/?astro-slot\>/g, ""));
+        yield markHTMLString(html.replace(/\<\/?astro-slot\b[^>]*>/g, ""));
       } else {
         yield "";
       }
@@ -3009,6 +3095,41 @@ if (typeof process !== "undefined") {
   }
 }
 
+async function callMiddleware(onRequest, apiContext, responseFunction) {
+  new Promise((resolve) => {
+  });
+  let nextCalled = false;
+  let responseFunctionPromise = void 0;
+  const next = async () => {
+    nextCalled = true;
+    responseFunctionPromise = responseFunction();
+    return responseFunctionPromise;
+  };
+  let middlewarePromise = onRequest(apiContext, next);
+  return await Promise.resolve(middlewarePromise).then(async (value) => {
+    if (nextCalled) {
+      if (typeof value !== "undefined") {
+        if (value instanceof Response === false) {
+          throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
+        }
+        return value;
+      } else {
+        if (responseFunctionPromise) {
+          return responseFunctionPromise;
+        } else {
+          throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
+        }
+      }
+    } else if (typeof value === "undefined") {
+      throw new AstroError(AstroErrorData.MiddlewareNoDataOrNextCalled);
+    } else if (value instanceof Response === false) {
+      throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
+    } else {
+      return value;
+    }
+  });
+}
+
 const VALID_PARAM_TYPES = ["string", "number", "undefined"];
 function validateGetStaticPathsParameter([key, value], route) {
   if (!VALID_PARAM_TYPES.includes(typeof value)) {
@@ -3190,7 +3311,7 @@ class Slots {
 }
 let renderMarkdown = null;
 function createResult(args) {
-  const { markdown, params, pathname, renderers, request, resolve } = args;
+  const { markdown, params, pathname, renderers, request, resolve, locals } = args;
   const url = new URL(request.url);
   const headers = new Headers();
   headers.set("Content-Type", "text/html");
@@ -3244,6 +3365,7 @@ function createResult(args) {
         },
         params,
         props,
+        locals,
         request,
         url,
         redirect: args.ssr ? (path, status) => {
@@ -3428,17 +3550,25 @@ function findPathItemByKey(staticPaths, params, route) {
   debug("findPathItemByKey", `Unexpected cache miss looking for ${paramsKey}`);
 }
 
-var GetParamsAndPropsError = /* @__PURE__ */ ((GetParamsAndPropsError2) => {
-  GetParamsAndPropsError2[GetParamsAndPropsError2["NoMatchingStaticPath"] = 0] = "NoMatchingStaticPath";
-  return GetParamsAndPropsError2;
-})(GetParamsAndPropsError || {});
+async function getParamsAndPropsOrThrow(options) {
+  var _a, _b;
+  let paramsAndPropsResp = await getParamsAndProps(options);
+  if (paramsAndPropsResp === 0 /* NoMatchingStaticPath */) {
+    throw new AstroError({
+      ...AstroErrorData.NoMatchingStaticPathFound,
+      message: AstroErrorData.NoMatchingStaticPathFound.message(options.pathname),
+      hint: ((_a = options.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = options.route) == null ? void 0 : _b.component]) : ""
+    });
+  }
+  return paramsAndPropsResp;
+}
 async function getParamsAndProps(opts) {
   const { logging, mod, route, routeCache, pathname, ssr } = opts;
   let params = {};
   let pageProps;
   if (route && !route.pathname) {
     if (route.params.length) {
-      const paramsMatch = route.pattern.exec(pathname);
+      const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
       if (paramsMatch) {
         params = getParams(route.params)(paramsMatch);
         if (route.type === "endpoint" && mod.getStaticPaths) {
@@ -3473,65 +3603,88 @@ async function getParamsAndProps(opts) {
   }
   return [params, pageProps];
 }
-async function renderPage(mod, ctx, env) {
-  var _a, _b;
-  const paramsAndPropsRes = await getParamsAndProps({
-    logging: env.logging,
-    mod,
-    route: ctx.route,
-    routeCache: env.routeCache,
-    pathname: ctx.pathname,
-    ssr: env.ssr
-  });
-  if (paramsAndPropsRes === 0 /* NoMatchingStaticPath */) {
-    throw new AstroError({
-      ...AstroErrorData.NoMatchingStaticPathFound,
-      message: AstroErrorData.NoMatchingStaticPathFound.message(ctx.pathname),
-      hint: ((_a = ctx.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = ctx.route) == null ? void 0 : _b.component]) : ""
-    });
-  }
-  const [params, pageProps] = paramsAndPropsRes;
+async function renderPage({ mod, renderContext, env, apiContext }) {
   const Component = mod.default;
   if (!Component)
     throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
+  let locals = {};
+  if (apiContext) {
+    if (env.mode === "development" && !isValueSerializable(apiContext.locals)) {
+      throw new AstroError({
+        ...AstroErrorData.LocalsNotSerializable,
+        message: AstroErrorData.LocalsNotSerializable.message(renderContext.pathname)
+      });
+    }
+    locals = apiContext.locals;
+  }
   const result = createResult({
     adapterName: env.adapterName,
-    links: ctx.links,
-    styles: ctx.styles,
+    links: renderContext.links,
+    styles: renderContext.styles,
     logging: env.logging,
     markdown: env.markdown,
     mode: env.mode,
-    origin: ctx.origin,
-    params,
-    props: pageProps,
-    pathname: ctx.pathname,
-    componentMetadata: ctx.componentMetadata,
+    origin: renderContext.origin,
+    params: renderContext.params,
+    props: renderContext.props,
+    pathname: renderContext.pathname,
+    componentMetadata: renderContext.componentMetadata,
     resolve: env.resolve,
     renderers: env.renderers,
-    request: ctx.request,
+    request: renderContext.request,
     site: env.site,
-    scripts: ctx.scripts,
+    scripts: renderContext.scripts,
     ssr: env.ssr,
-    status: ctx.status ?? 200
+    status: renderContext.status ?? 200,
+    locals
   });
   if (typeof mod.components === "object") {
-    Object.assign(pageProps, { components: mod.components });
+    Object.assign(renderContext.props, { components: mod.components });
   }
-  const response = await renderPage$1(
+  let response = await renderPage$1(
     result,
     Component,
-    pageProps,
+    renderContext.props,
     null,
     env.streaming,
-    ctx.route
+    renderContext.route
   );
   if (result.cookies) {
     attachToResponse(response, result.cookies);
   }
   return response;
 }
+function isValueSerializable(value) {
+  let type = typeof value;
+  let plainObject = true;
+  if (type === "object" && isPlainObject(value)) {
+    for (const [, nestedValue] of Object.entries(value)) {
+      if (!isValueSerializable(nestedValue)) {
+        plainObject = false;
+        break;
+      }
+    }
+  } else {
+    plainObject = false;
+  }
+  let result = value === null || type === "string" || type === "number" || type === "boolean" || Array.isArray(value) || plainObject;
+  return result;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = Object.getPrototypeOf(value);
+  if (proto === null)
+    return true;
+  let baseProto = proto;
+  while (Object.getPrototypeOf(baseProto) !== null) {
+    baseProto = Object.getPrototypeOf(baseProto);
+  }
+  return proto === baseProto;
+}
 
 const clientAddressSymbol$1 = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol$1 = Symbol.for("astro.locals");
 function createAPIContext({
   request,
   params,
@@ -3539,7 +3692,7 @@ function createAPIContext({
   props,
   adapterName
 }) {
-  return {
+  const context = {
     cookies: new AstroCookies(request),
     request,
     params,
@@ -3555,7 +3708,6 @@ function createAPIContext({
       });
     },
     url: new URL(request.url),
-    // @ts-expect-error
     get clientAddress() {
       if (!(clientAddressSymbol$1 in request)) {
         if (adapterName) {
@@ -3570,33 +3722,49 @@ function createAPIContext({
       return Reflect.get(request, clientAddressSymbol$1);
     }
   };
-}
-async function call(mod, env, ctx, logging) {
-  var _a, _b;
-  const paramsAndPropsResp = await getParamsAndProps({
-    mod,
-    route: ctx.route,
-    routeCache: env.routeCache,
-    pathname: ctx.pathname,
-    logging: env.logging,
-    ssr: env.ssr
+  Object.defineProperty(context, "locals", {
+    get() {
+      return Reflect.get(request, clientLocalsSymbol$1);
+    },
+    set(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(AstroErrorData.LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol$1, val);
+      }
+    }
   });
-  if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
-    throw new AstroError({
-      ...AstroErrorData.NoMatchingStaticPathFound,
-      message: AstroErrorData.NoMatchingStaticPathFound.message(ctx.pathname),
-      hint: ((_a = ctx.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = ctx.route) == null ? void 0 : _b.component]) : ""
-    });
-  }
-  const [params, props] = paramsAndPropsResp;
+  return context;
+}
+async function call(mod, env, ctx, logging, middleware) {
   const context = createAPIContext({
     request: ctx.request,
-    params,
-    props,
+    params: ctx.params,
+    props: ctx.props,
     site: env.site,
     adapterName: env.adapterName
   });
-  const response = await renderEndpoint(mod, context, env.ssr);
+  let response = await renderEndpoint(mod, context, env.ssr);
+  if (middleware && middleware.onRequest) {
+    if (response.body === null) {
+      const onRequest = middleware.onRequest;
+      response = await callMiddleware(onRequest, context, async () => {
+        if (env.mode === "development" && !isValueSerializable(context.locals)) {
+          throw new AstroError({
+            ...AstroErrorData.LocalsNotSerializable,
+            message: AstroErrorData.LocalsNotSerializable.message(ctx.pathname)
+          });
+        }
+        return response;
+      });
+    } else {
+      warn(
+        env.logging,
+        "middleware",
+        "Middleware doesn't work for endpoints that return a simple body. The middleware will be disabled for this page."
+      );
+    }
+  }
   if (response instanceof Response) {
     attachToResponse(response, context.cookies);
     return {
@@ -3672,6 +3840,9 @@ function prependForwardSlash(path) {
 function removeTrailingForwardSlash(path) {
   return path.endsWith("/") ? path.slice(0, path.length - 1) : path;
 }
+function removeLeadingForwardSlash(path) {
+  return path.startsWith("/") ? path.substring(1) : path;
+}
 function trimSlashes(path) {
   return path.replace(/^\/|\/$/g, "");
 }
@@ -3679,19 +3850,37 @@ function isString(path) {
   return typeof path === "string" || path instanceof String;
 }
 function joinPaths(...paths) {
-  return paths.filter(isString).map(trimSlashes).join("/");
+  return paths.filter(isString).map((path, i) => {
+    if (i === 0) {
+      return removeTrailingForwardSlash(path);
+    } else if (i === paths.length - 1) {
+      return removeLeadingForwardSlash(path);
+    } else {
+      return trimSlashes(path);
+    }
+  }).join("/");
 }
 
-function createRenderContext(options) {
+async function createRenderContext(options) {
   const request = options.request;
   const url = new URL(request.url);
   const origin = options.origin ?? url.origin;
   const pathname = options.pathname ?? url.pathname;
+  const [params, props] = await getParamsAndPropsOrThrow({
+    mod: options.mod,
+    route: options.route,
+    routeCache: options.env.routeCache,
+    pathname,
+    logging: options.env.logging,
+    ssr: options.env.ssr
+  });
   return {
     ...options,
     origin,
     pathname,
-    url
+    url,
+    params,
+    props
   };
 }
 
@@ -3708,19 +3897,26 @@ function createAssetLink(href, base, assetsPrefix) {
     return href;
   }
 }
-function createLinkStylesheetElement(href, base, assetsPrefix) {
-  return {
-    props: {
-      rel: "stylesheet",
-      href: createAssetLink(href, base, assetsPrefix)
-    },
-    children: ""
-  };
+function createStylesheetElement(stylesheet, base, assetsPrefix) {
+  if (stylesheet.type === "inline") {
+    return {
+      props: {
+        type: "text/css"
+      },
+      children: stylesheet.content
+    };
+  } else {
+    return {
+      props: {
+        rel: "stylesheet",
+        href: createAssetLink(stylesheet.src, base, assetsPrefix)
+      },
+      children: ""
+    };
+  }
 }
-function createLinkStylesheetElementSet(hrefs, base, assetsPrefix) {
-  return new Set(
-    hrefs.map((href) => createLinkStylesheetElement(href, base, assetsPrefix))
-  );
+function createStylesheetElementSet(stylesheets, base, assetsPrefix) {
+  return new Set(stylesheets.map((s) => createStylesheetElement(s, base, assetsPrefix)));
 }
 function createModuleScriptElement(script, base, assetsPrefix) {
   if (script.type === "external") {
@@ -3748,6 +3944,7 @@ function matchRoute(pathname, manifest) {
   return manifest.routes.find((route) => route.pattern.test(decodeURI(pathname)));
 }
 
+const clientLocalsSymbol = Symbol.for("astro.locals");
 const responseSentSymbol = Symbol.for("astro.responseSent");
 class App {
   #env;
@@ -3784,7 +3981,7 @@ class App {
             return bundlePath;
           }
           default: {
-            return prependForwardSlash(joinPaths(manifest.base, bundlePath));
+            return createAssetLink(bundlePath, manifest.base, manifest.assetsPrefix);
           }
         }
       },
@@ -3837,6 +4034,7 @@ class App {
         });
       }
     }
+    Reflect.set(request, clientLocalsSymbol, {});
     if (routeData.route === "/404") {
       defaultStatus = 404;
     }
@@ -3870,10 +4068,12 @@ class App {
     return getSetCookiesFromResponse(response);
   }
   async #renderPage(request, routeData, mod, status = 200) {
+    var _a;
     const url = new URL(request.url);
     const pathname = "/" + this.removeBase(url.pathname);
     const info = this.#routeDataToRouteInfo.get(routeData);
-    const links = createLinkStylesheetElementSet(info.links);
+    const links = /* @__PURE__ */ new Set();
+    const styles = createStylesheetElementSet(info.styles);
     let scripts = /* @__PURE__ */ new Set();
     for (const script of info.scripts) {
       if ("stage" in script) {
@@ -3888,17 +4088,44 @@ class App {
       }
     }
     try {
-      const ctx = createRenderContext({
+      const renderContext = await createRenderContext({
         request,
         origin: url.origin,
         pathname,
         componentMetadata: this.#manifest.componentMetadata,
         scripts,
+        styles,
         links,
         route: routeData,
-        status
+        status,
+        mod,
+        env: this.#env
+      });
+      const apiContext = createAPIContext({
+        request: renderContext.request,
+        params: renderContext.params,
+        props: renderContext.props,
+        site: this.#env.site,
+        adapterName: this.#env.adapterName
       });
-      const response = await renderPage(mod, ctx, this.#env);
+      const onRequest = (_a = this.#manifest.middleware) == null ? void 0 : _a.onRequest;
+      let response;
+      if (onRequest) {
+        response = await callMiddleware(
+          onRequest,
+          apiContext,
+          () => {
+            return renderPage({ mod, renderContext, env: this.#env, apiContext });
+          }
+        );
+      } else {
+        response = await renderPage({
+          mod,
+          renderContext,
+          env: this.#env,
+          apiContext
+        });
+      }
       Reflect.set(request, responseSentSymbol, true);
       return response;
     } catch (err) {
@@ -3913,14 +4140,22 @@ class App {
     const url = new URL(request.url);
     const pathname = "/" + this.removeBase(url.pathname);
     const handler = mod;
-    const ctx = createRenderContext({
+    const ctx = await createRenderContext({
       request,
       origin: url.origin,
       pathname,
       route: routeData,
-      status
+      status,
+      env: this.#env,
+      mod: handler
     });
-    const result = await call(handler, this.#env, ctx, this.#logging);
+    const result = await call(
+      handler,
+      this.#env,
+      ctx,
+      this.#logging,
+      this.#manifest.middleware
+    );
     if (result.type === "response") {
       if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
         const fourOhFourRequest = new Request(new URL("/404", request.url));