@wix/astro 2.18.0 → 2.20.0

package/build/dependencies/astro-auth/backend-runtime/chunk-24J7STEA.js

@@ -0,0 +1,8 @@
+// src/constants.ts
+var oAuthStateCookieName = "oAuthState";
+var returnToQueryParamName = "returnTo";
+
+export {
+  oAuthStateCookieName,
+  returnToQueryParamName
+};

package/build/dependencies/astro-auth/backend-runtime/chunk-352W54SQ.js

@@ -0,0 +1,70 @@
+import {
+  authAsyncLocalStorage,
+  createHost
+} from "./chunk-USQSPPTM.js";
+
+// src/runtime/backend/contextualClient.ts
+import { createClient } from "@wix/sdk";
+
+// src/runtime/backend/hostProxy.ts
+var defaultHost = createHost();
+var resolveHostForCurrentRequest = () => {
+  const store = authAsyncLocalStorage.getStore();
+  return store?.sdkHost ?? defaultHost;
+};
+var hostProxy = new Proxy(
+  {},
+  {
+    get(target, prop) {
+      const host = resolveHostForCurrentRequest();
+      const value = host[prop];
+      if (typeof value !== "function") {
+        return value;
+      }
+      return function(...args) {
+        const anotherHost = resolveHostForCurrentRequest();
+        return (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+          anotherHost[prop].apply(
+            anotherHost,
+            args
+          )
+        );
+      };
+    }
+  }
+);
+
+// src/runtime/backend/contextualClient.ts
+var contextualClient = createClient({
+  auth: () => {
+    const store = authAsyncLocalStorage.getStore();
+    if (store?.auth == null) {
+      throw new Error(
+        "Cannot find authentication on `AsyncLocalStorage` instance"
+      );
+    }
+    return store.auth;
+  },
+  host: hostProxy
+});
+
+// src/runtime/backend/elevatedContextualClient.ts
+import { createClient as createClient2 } from "@wix/sdk";
+var elevatedContextualClient = createClient2({
+  auth: () => {
+    const store = authAsyncLocalStorage.getStore();
+    if (store?.elevatedAuth == null) {
+      throw new Error(
+        "Cannot find authentication on `AsyncLocalStorage` instance"
+      );
+    }
+    return store.elevatedAuth;
+  },
+  host: hostProxy
+});
+
+export {
+  contextualClient,
+  elevatedContextualClient
+};

package/build/dependencies/astro-auth/backend-runtime/chunk-USQSPPTM.js

@@ -0,0 +1,14 @@
+// src/utils/authAsyncLocalStorage.ts
+import { AsyncLocalStorage } from "async_hooks";
+var authAsyncLocalStorage = new AsyncLocalStorage();
+
+// src/utils/host-utils.ts
+import { headlessNode } from "@wix/headless-node";
+function createHost(request, essentials) {
+  return headlessNode.host({ essentials, req: request });
+}
+
+export {
+  authAsyncLocalStorage,
+  createHost
+};

package/build/dependencies/astro-auth/backend-runtime/middleware/auth.js

@@ -2,12 +2,23 @@ import {
   saveSessionTokensToCookie
 } from "../chunk-HPW4ZAEJ.js";
 import {
-  authAsyncLocalStorage
-} from "../chunk-IUZYED2S.js";
+  contextualClient,
+  elevatedContextualClient
+} from "../chunk-352W54SQ.js";
+import {
+  authAsyncLocalStorage,
+  createHost
+} from "../chunk-USQSPPTM.js";
 import "../chunk-MLKGABMK.js";
 
 // src/middleware/auth.ts
-import { headlessNode } from "@wix/headless-node";
+import { AppStrategy, OAuthStrategy as OAuthStrategy2 } from "@wix/sdk";
+import { WIX_CLIENT_ID as WIX_CLIENT_ID3 } from "astro:env/client";
+import {
+  WIX_CLIENT_INSTANCE_ID,
+  WIX_CLIENT_PUBLIC_KEY,
+  WIX_CLIENT_SECRET
+} from "astro:env/server";
 
 // src/utils/generateVisitorTokens.ts
 import { OAuthStrategy } from "@wix/sdk";
@@ -50,30 +61,67 @@ function getSessionTokensFromCookie(context) {
 }
 
 // src/middleware/auth.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });
 var onRequest = async (context, next) => {
   if (context.url.pathname.startsWith("/_wix/extensions/")) {
     return next();
   }
-  const existingTokens = getExistingTokens(context);
-  const usedTokens = existingTokens ?? await generateVisitorTokens();
-  const store = {
-    sdkHost: headlessNode.host({ req: context.request }),
-    sessionTokens: usedTokens
-  };
-  const response = await authAsyncLocalStorage.run(store, async () => {
-    return next();
-  });
-  const contentType = response.headers.get("Content-Type");
-  if (contentType !== "text/html") {
-    return response;
+  const accessToken = context.request.headers.get("Authorization");
+  if (accessToken != null) {
+    const auth2 = AppStrategy({
+      accessToken,
+      appId: WIX_CLIENT_ID3
+    });
+    const elevatedAuth = await auth2.elevated();
+    return authAsyncLocalStorage.run(
+      {
+        auth: auth2,
+        elevatedAuth,
+        sdkHost: createHost(context.request)
+      },
+      async () => next()
+    );
   }
-  if (context.isPrerendered) {
-    return response;
+  const existingToken = getExistingTokens(context);
+  if (existingToken) {
+    return authAsyncLocalStorage.run(
+      {
+        auth: OAuthStrategy2({
+          clientId: WIX_CLIENT_ID3,
+          tokens: existingToken
+        }),
+        elevatedAuth: AppStrategy({
+          appId: WIX_CLIENT_ID3,
+          appSecret: WIX_CLIENT_SECRET,
+          instanceId: WIX_CLIENT_INSTANCE_ID,
+          publicKey: WIX_CLIENT_PUBLIC_KEY
+        }),
+        sdkHost: createHost(context.request)
+      },
+      async () => next()
+    );
   }
-  if (existingTokens === usedTokens) {
-    return response;
+  const visitorToken = await generateVisitorTokens();
+  if (context.request.headers.get("Accept")?.includes("text/html") && !context.isPrerendered) {
+    saveSessionTokensToCookie(context, visitorToken);
   }
-  saveSessionTokensToCookie(context, usedTokens);
+  const response = await authAsyncLocalStorage.run(
+    {
+      auth: OAuthStrategy2({
+        clientId: WIX_CLIENT_ID3,
+        tokens: visitorToken
+      }),
+      elevatedAuth: AppStrategy({
+        appId: WIX_CLIENT_ID3,
+        appSecret: WIX_CLIENT_SECRET,
+        instanceId: WIX_CLIENT_INSTANCE_ID,
+        publicKey: WIX_CLIENT_PUBLIC_KEY
+      }),
+      sdkHost: createHost(context.request)
+    },
+    async () => next()
+  );
   return response;
 };
 function getExistingTokens(context) {

package/build/dependencies/astro-auth/backend-runtime/middleware/localization.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareHandler } from 'astro';
+
+declare const onRequest: MiddlewareHandler;
+
+export { onRequest };

package/build/dependencies/astro-auth/backend-runtime/middleware/localization.js

@@ -0,0 +1,219 @@
+import {
+  authAsyncLocalStorage,
+  createHost
+} from "../chunk-USQSPPTM.js";
+import "../chunk-MLKGABMK.js";
+
+// ../request-transform-utils/src/transformStreamUtils.ts
+function injectBeforeTransformStream(predicate, htmlToInject) {
+  let hasInjected = false;
+  return new TransformStream({
+    transform: (chunk, controller) => {
+      if (!hasInjected) {
+        const index = chunk.indexOf(predicate);
+        if (index > -1) {
+          chunk = chunk.slice(0, index) + htmlToInject + chunk.slice(index);
+          hasInjected = true;
+        }
+      }
+      controller.enqueue(chunk);
+    }
+  });
+}
+
+// ../request-transform-utils/src/index.ts
+var headTransformStream = (htmlToInject) => injectBeforeTransformStream("</head>", htmlToInject);
+
+// ../../node_modules/outdent/lib-module/index.js
+function noop() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+}
+function createWeakMap() {
+  if (typeof WeakMap !== "undefined") {
+    return /* @__PURE__ */ new WeakMap();
+  } else {
+    return fakeSetOrMap();
+  }
+}
+function fakeSetOrMap() {
+  return {
+    add: noop,
+    delete: noop,
+    get: noop,
+    set: noop,
+    has: function(k) {
+      return false;
+    }
+  };
+}
+var hop = Object.prototype.hasOwnProperty;
+var has = function(obj, prop) {
+  return hop.call(obj, prop);
+};
+function extend(target, source) {
+  for (var prop in source) {
+    if (has(source, prop)) {
+      target[prop] = source[prop];
+    }
+  }
+  return target;
+}
+var reLeadingNewline = /^[ \t]*(?:\r\n|\r|\n)/;
+var reTrailingNewline = /(?:\r\n|\r|\n)[ \t]*$/;
+var reStartsWithNewlineOrIsEmpty = /^(?:[\r\n]|$)/;
+var reDetectIndentation = /(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/;
+var reOnlyWhitespaceWithAtLeastOneNewline = /^[ \t]*[\r\n][ \t\r\n]*$/;
+function _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options) {
+  var indentationLevel = 0;
+  var match = strings[0].match(reDetectIndentation);
+  if (match) {
+    indentationLevel = match[1].length;
+  }
+  var reSource = "(\\r\\n|\\r|\\n).{0," + indentationLevel + "}";
+  var reMatchIndent = new RegExp(reSource, "g");
+  if (firstInterpolatedValueSetsIndentationLevel) {
+    strings = strings.slice(1);
+  }
+  var newline = options.newline, trimLeadingNewline = options.trimLeadingNewline, trimTrailingNewline = options.trimTrailingNewline;
+  var normalizeNewlines = typeof newline === "string";
+  var l = strings.length;
+  var outdentedStrings = strings.map(function(v, i) {
+    v = v.replace(reMatchIndent, "$1");
+    if (i === 0 && trimLeadingNewline) {
+      v = v.replace(reLeadingNewline, "");
+    }
+    if (i === l - 1 && trimTrailingNewline) {
+      v = v.replace(reTrailingNewline, "");
+    }
+    if (normalizeNewlines) {
+      v = v.replace(/\r\n|\n|\r/g, function(_) {
+        return newline;
+      });
+    }
+    return v;
+  });
+  return outdentedStrings;
+}
+function concatStringsAndValues(strings, values) {
+  var ret = "";
+  for (var i = 0, l = strings.length; i < l; i++) {
+    ret += strings[i];
+    if (i < l - 1) {
+      ret += values[i];
+    }
+  }
+  return ret;
+}
+function isTemplateStringsArray(v) {
+  return has(v, "raw") && has(v, "length");
+}
+function createInstance(options) {
+  var arrayAutoIndentCache = createWeakMap();
+  var arrayFirstInterpSetsIndentCache = createWeakMap();
+  function outdent(stringsOrOptions) {
+    var values = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      values[_i - 1] = arguments[_i];
+    }
+    if (isTemplateStringsArray(stringsOrOptions)) {
+      var strings = stringsOrOptions;
+      var firstInterpolatedValueSetsIndentationLevel = (values[0] === outdent || values[0] === defaultOutdent) && reOnlyWhitespaceWithAtLeastOneNewline.test(strings[0]) && reStartsWithNewlineOrIsEmpty.test(strings[1]);
+      var cache = firstInterpolatedValueSetsIndentationLevel ? arrayFirstInterpSetsIndentCache : arrayAutoIndentCache;
+      var renderedArray = cache.get(strings);
+      if (!renderedArray) {
+        renderedArray = _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
+        cache.set(strings, renderedArray);
+      }
+      if (values.length === 0) {
+        return renderedArray[0];
+      }
+      var rendered = concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
+      return rendered;
+    } else {
+      return createInstance(extend(extend({}, options), stringsOrOptions || {}));
+    }
+  }
+  var fullOutdent = extend(outdent, {
+    string: function(str) {
+      return _outdentArray([str], false, options)[0];
+    }
+  });
+  return fullOutdent;
+}
+var defaultOutdent = createInstance({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true
+});
+if (typeof module !== "undefined") {
+  try {
+    module.exports = defaultOutdent;
+    Object.defineProperty(defaultOutdent, "__esModule", { value: true });
+    defaultOutdent.default = defaultOutdent;
+    defaultOutdent.outdent = defaultOutdent;
+  } catch (e) {
+  }
+}
+
+// src/utils/localizationUtils.ts
+import {
+  getLocalizationData as getLocalizationDataFromUtils,
+  MULTILINGUAL_COOKIE_HEADER_KEY
+} from "@wix/headless-localization-utils";
+import { scripts } from "@wix/headless-site-assets";
+async function getLocalizationData(context) {
+  return getLocalizationDataFromUtils(
+    context.url,
+    context.request.headers,
+    (await scripts.getSiteMetadata()).properties ?? {}
+  );
+}
+function setMultilingualCookie(context, language) {
+  if (context.cookies.get(MULTILINGUAL_COOKIE_HEADER_KEY)?.value !== language) {
+    context.cookies.set(MULTILINGUAL_COOKIE_HEADER_KEY, language, {
+      httpOnly: false,
+      path: "/",
+      sameSite: "lax"
+    });
+  }
+}
+
+// src/middleware/localization.ts
+var onRequest = async (context, next) => {
+  const store = authAsyncLocalStorage.getStore();
+  if (!store) {
+    return next();
+  }
+  let localizationData;
+  try {
+    localizationData = await getLocalizationData(context);
+  } catch {
+    return next();
+  }
+  const { cleanUrl, essentials } = localizationData;
+  if (essentials.language == null || essentials.multilingual === void 0) {
+    return next();
+  }
+  store.sdkHost = createHost(context.request, essentials);
+  setMultilingualCookie(context, essentials.language);
+  const nextResponse = cleanUrl !== context.url.href ? await next(cleanUrl) : await next();
+  return modifyHtmlEmbed(nextResponse, context, essentials);
+};
+function modifyHtmlEmbed(response, context, essentials) {
+  const contentType = response.headers.get("Content-Type");
+  if (contentType !== "text/html" || context.url.pathname.startsWith("/_wix") || !response.body) {
+    return response;
+  }
+  const essentialsScript = defaultOutdent`
+    <script>window.essentials = ${JSON.stringify(essentials)};</script>
+  `;
+  return new Response(
+    response.body.pipeThrough(new TextDecoderStream()).pipeThrough(headTransformStream(essentialsScript)).pipeThrough(new TextEncoderStream()),
+    response
+  );
+}
+export {
+  onRequest
+};

package/build/dependencies/astro-auth/backend-runtime/routes/callback.js

@@ -6,12 +6,12 @@ import {
   string
 } from "../chunk-BIARYLOZ.js";
 import {
-  auth,
   oAuthStateCookieName
-} from "../chunk-YHKPE45V.js";
+} from "../chunk-24J7STEA.js";
 import "../chunk-MLKGABMK.js";
 
 // src/routes/callback.ts
+import { getContextualAuth } from "@wix/sdk-runtime/context";
 var oauthCookieSchema = object({
   codeChallenge: string(),
   codeVerifier: string(),
@@ -30,6 +30,7 @@ var GET = async (context) => {
       "Invalid `originalUri` cookie param, only relative URLs are allowed"
     );
   }
+  const auth = getContextualAuth();
   const { code, error, errorDescription, state } = auth.parseFromUrl(
     context.url.toString(),
     "query"

package/build/dependencies/astro-auth/backend-runtime/routes/login.js

@@ -4,12 +4,12 @@ import {
   string
 } from "../chunk-BIARYLOZ.js";
 import {
-  auth,
   oAuthStateCookieName
-} from "../chunk-YHKPE45V.js";
+} from "../chunk-24J7STEA.js";
 import "../chunk-MLKGABMK.js";
 
 // src/routes/login.ts
+import { getContextualAuth } from "@wix/sdk-runtime/context";
 var loginSearchParams = object({
   prompt: _enum(["login", "none"]).optional(),
   returnToUrl: string().optional()
@@ -24,6 +24,7 @@ var GET = async ({ request, url }) => {
     const originalUrl = new URL(referer);
     callbackUrl.protocol = originalUrl.protocol;
   }
+  const auth = getContextualAuth();
   const oauthData = auth.generateOAuthData(callbackUrl.toString(), returnToUrl);
   const { authUrl } = await auth.getAuthUrl(oauthData, {
     prompt,

package/build/dependencies/astro-auth/backend-runtime/routes/logout-callback.js

@@ -2,12 +2,12 @@ import {
   saveSessionTokensToCookie
 } from "../chunk-HPW4ZAEJ.js";
 import {
-  auth,
   returnToQueryParamName
-} from "../chunk-YHKPE45V.js";
+} from "../chunk-24J7STEA.js";
 import "../chunk-MLKGABMK.js";
 
 // src/routes/logout-callback.ts
+import { getContextualAuth } from "@wix/sdk-runtime/context";
 var GET = async (context) => {
   const returnTo = context.url.searchParams.get(returnToQueryParamName) ?? "/";
   if (!returnTo.startsWith("/")) {
@@ -15,6 +15,7 @@ var GET = async (context) => {
       `Invalid \`${returnToQueryParamName}\` query param, only relative URLs are allowed`
     );
   }
+  const auth = getContextualAuth();
   saveSessionTokensToCookie(context, await auth.generateVisitorTokens());
   return context.redirect(returnTo);
 };

package/build/dependencies/astro-auth/backend-runtime/routes/logout.js

@@ -3,12 +3,12 @@ import {
   string
 } from "../chunk-BIARYLOZ.js";
 import {
-  auth,
   returnToQueryParamName
-} from "../chunk-YHKPE45V.js";
+} from "../chunk-24J7STEA.js";
 import "../chunk-MLKGABMK.js";
 
 // src/routes/logout.ts
+import { getContextualAuth } from "@wix/sdk-runtime/context";
 var logoutSearchParams = object({
   returnToUrl: string().optional()
 });
@@ -24,6 +24,7 @@ var POST = async ({ redirect, request, url }) => {
     postFlowUrl.protocol = originalUrl.protocol;
   }
   postFlowUrl.searchParams.set(returnToQueryParamName, returnToUrl);
+  const auth = getContextualAuth();
   const { logoutUrl } = await auth.logout(postFlowUrl.toString());
   return redirect(logoutUrl);
 };

package/build/dependencies/astro-auth/backend-runtime/runtime/backend/setupContextualClient.js

@@ -1,2 +1,10 @@
-import "../../chunk-IUZYED2S.js";
+import {
+  contextualClient,
+  elevatedContextualClient
+} from "../../chunk-352W54SQ.js";
+import "../../chunk-USQSPPTM.js";
 import "../../chunk-MLKGABMK.js";
+
+// src/runtime/backend/setupContextualClient.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });

package/build/dependencies/astro-backend-extensions/backend-runtime/chunk-CPGTXQVH.js

@@ -0,0 +1,75 @@
+// src/runtime/contextualClient.ts
+import { createClient } from "@wix/sdk";
+var elevateNeededError = new Error(
+  "Contextual client is not available for events and service plugins, please use elevate() instead."
+);
+var contextualClient = createClient({
+  auth: {
+    getActiveToken: () => {
+      throw elevateNeededError;
+    },
+    getAuthHeaders: async () => {
+      throw elevateNeededError;
+    }
+  }
+});
+
+// src/runtime/authAsyncLocalStorage.ts
+import { AsyncLocalStorage } from "async_hooks";
+var authAsyncLocalStorage = new AsyncLocalStorage();
+
+// src/runtime/elevatedContextualClient.ts
+import { createClient as createClient2 } from "@wix/sdk";
+var elevatedContextualClient = createClient2({
+  auth: {
+    getAuthHeaders: async (host) => {
+      const store = authAsyncLocalStorage.getStore();
+      if (!store) {
+        throw new Error("Cannot find an authentication strategy");
+      }
+      if (store.elevatedAuth) {
+        return store.elevatedAuth.getAuthHeaders(host);
+      }
+      throw new Error("Cannot find an elevated authentication strategy");
+    }
+  }
+});
+
+// src/runtime/utils.ts
+import { AppStrategy, createClient as createClient3 } from "@wix/sdk";
+import { wixContext } from "@wix/sdk-context";
+function createAppStrategy(opts = {}) {
+  return AppStrategy({
+    ...opts,
+    appId: import.meta.env.WIX_CLIENT_ID
+  });
+}
+async function setupClient(fn) {
+  let authOptions = {};
+  const client = createClient3({
+    auth: () => AppStrategy({
+      appId: import.meta.env.WIX_CLIENT_ID,
+      ...authOptions
+    })
+  });
+  const olderClient = wixContext.client;
+  client.enableContext("module");
+  await fn();
+  if (olderClient) {
+    olderClient.enableContext("module");
+  }
+  return {
+    client,
+    setAuthOptions: (options) => {
+      authOptions = options;
+    }
+  };
+}
+
+export {
+  contextualClient,
+  authAsyncLocalStorage,
+  elevatedContextualClient,
+  createAppStrategy,
+  setupClient
+};

package/build/dependencies/astro-backend-extensions/backend-runtime/routes/extensions.js

@@ -0,0 +1,41 @@
+// src/routes/extensions.ts
+import { WIX_CLIENT_PUBLIC_KEY, WIX_CLIENT_SECRET } from "astro:env/server";
+var authOptions = {
+  appSecret: WIX_CLIENT_SECRET,
+  publicKey: WIX_CLIENT_PUBLIC_KEY
+};
+var runExtension = await createServeExtensionRunner();
+var ALL = async (context) => {
+  const componentId = context.params.compId;
+  if (componentId == null) {
+    return new Response(null, { status: 404 });
+  }
+  try {
+    return await runExtension({
+      componentId,
+      payload: await context.request.text(),
+      url: context.request.url
+    });
+  } catch (error) {
+    return Response.json(error, { status: 500 });
+  }
+};
+async function createServeExtensionRunner() {
+  const { entries } = await import("@virtual/wix-backend-entries");
+  return async ({
+    componentId,
+    payload,
+    url
+  }) => {
+    const loadModule = entries[componentId];
+    if (loadModule == null) {
+      return new Response(null, { status: 404 });
+    }
+    const module = await loadModule();
+    const result = await module.default({ authOptions, payload, url });
+    return Response.json(result ?? null);
+  };
+}
+export {
+  ALL
+};

package/build/dependencies/astro-backend-extensions/backend-runtime/runtime/setupServicePlugin.d.ts

@@ -1,5 +1,10 @@
-import { APIRoute } from 'astro';
+import { A as AppStrategyOptions } from '../utils-B7jr2PES.js';
+import '@wix/sdk';
 
-declare function setupServicePlugin(fn: () => Promise<unknown>): Promise<APIRoute>;
+declare function setupServicePlugin(fn: () => Promise<unknown>): Promise<({ authOptions, payload, url, }: {
+    authOptions: AppStrategyOptions;
+    payload: string;
+    url: string;
+}) => Promise<unknown>>;
 
 export { setupServicePlugin };