@weaverse/next 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/server.mjs

@@ -1,4 +1,6 @@
-import { generateDataFromSchema, buildWeaverseNextRequestInfo, runWeaverseComponentLoaders } from './chunk-SS6QUKYY.mjs';
+import { withPathPrefix, generateDataFromSchema, sanitizeRouteContextSearch, buildWeaverseNextRequestInfo, runWeaverseComponentLoaders, ROUTE_CONTEXT_I18N_KEYS } from './chunk-LH6AAEIK.mjs';
+export { formatWeaverseNextSeoMetadata, getWeaverseNextSeoMetadata } from './chunk-LH6AAEIK.mjs';
+import { PageTypeSchema } from '@weaverse/schema';
 
 // src/server/configs.ts
 var DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
@@ -71,7 +73,6 @@ function getWeaverseNextConfigs(context, options = {}) {
     envProjectId: readEnv(env, "WEAVERSE_PROJECT_ID") || "",
     weaverseHost,
     weaverseApiBase,
-    weaverseApiKey: lastParam(searchParams, "weaverseApiKey") || readEnv(env, "WEAVERSE_API_KEY") || "",
     weaverseVersion: lastParam(searchParams, "weaverseVersion") || options.weaverseVersion || "",
     isDesignMode,
     isPreviewMode,
@@ -85,7 +86,7 @@ function getWeaverseNextConfigs(context, options = {}) {
 }
 
 // src/server/normalize-page-url.ts
-var KEPT_PARAM_RE = /^(?:__revisionId|isDesignMode|weaverse)/;
+var KEPT_PARAM_RE = /^(?:__revisionId|__weaverseDraftItem|isDesignMode|weaverse)/;
 var DATA_SUFFIX = ".data";
 function normalizeNextPageUrl(url) {
   let parsed;
@@ -109,17 +110,228 @@ function normalizeNextPageUrl(url) {
 }
 function resolveRequestUrl(context) {
   if (context?.url) {
-    return typeof context.url === "string" ? context.url : context.url.toString();
+    let raw = String(context.url);
+    let url = new URL(raw, "http://localhost");
+    let pathname2 = withPathPrefix(url.pathname, context.i18n);
+    if (pathname2 === url.pathname) {
+      return raw;
+    }
+    url.pathname = pathname2;
+    return url.toString();
   }
-  let pathname = context?.pathname || "/";
+  let pathname = withPathPrefix(context?.pathname || "/", context?.i18n);
   let search = context?.searchParams ? new URLSearchParams(context.searchParams).toString() : "";
   return `http://localhost${pathname}${search ? `?${search}` : ""}`;
 }
+var NO_STORE_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+var STATUS_OK = 200;
+var STATUS_BAD_REQUEST = 400;
+var STATUS_NOT_FOUND = 404;
+var STATUS_UNPROCESSABLE = 422;
+var STATUS_SERVER_ERROR = 500;
+var MAX_PATHNAME_LENGTH = 2048;
+var MAX_SEARCH_LENGTH = 8192;
+var MAX_HANDLE_LENGTH = 512;
+var MAX_I18N_FIELD_LENGTH = 256;
+var CONTROL_CHAR_PATTERN = /[\u0000-\u001F\u007F]/;
+function isValidPathname(pathname) {
+  if (!pathname || pathname.length > MAX_PATHNAME_LENGTH) {
+    return false;
+  }
+  if (pathname[0] !== "/" || pathname.startsWith("//")) {
+    return false;
+  }
+  if (pathname.includes("\\") || pathname.includes("?")) {
+    return false;
+  }
+  if (pathname.includes("#") || CONTROL_CHAR_PATTERN.test(pathname)) {
+    return false;
+  }
+  return true;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  let proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function sanitizeRouteContextI18n(input) {
+  if (input === void 0) {
+    return;
+  }
+  if (!isPlainObject(input)) {
+    return null;
+  }
+  let source = input;
+  let allowed = new Set(ROUTE_CONTEXT_I18N_KEYS);
+  for (let key of Object.keys(source)) {
+    if (!allowed.has(key)) {
+      return null;
+    }
+  }
+  let result = {};
+  for (let key of ROUTE_CONTEXT_I18N_KEYS) {
+    let value = source[key];
+    if (value === void 0) {
+      continue;
+    }
+    if (typeof value !== "string" || value.length > MAX_I18N_FIELD_LENGTH) {
+      return null;
+    }
+    result[key] = value;
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+function reconstructRouteContext(request, routeContext) {
+  if (typeof routeContext !== "object" || routeContext === null || Array.isArray(routeContext)) {
+    return null;
+  }
+  let { pathname, search, handle, pageType, i18n } = routeContext;
+  if (typeof pathname !== "string" || !isValidPathname(pathname)) {
+    return null;
+  }
+  if (typeof search !== "string" || search.length > MAX_SEARCH_LENGTH) {
+    return null;
+  }
+  let rawSearch = search;
+  if (rawSearch.length && !rawSearch.startsWith("?")) {
+    return null;
+  }
+  let sanitizedI18n = sanitizeRouteContextI18n(i18n);
+  if (sanitizedI18n === null) {
+    return null;
+  }
+  let resolvedPageType;
+  if (pageType !== void 0) {
+    let parsed = PageTypeSchema.safeParse(pageType);
+    if (!parsed.success) {
+      return null;
+    }
+    resolvedPageType = parsed.data;
+  }
+  let resolvedHandle;
+  if (handle !== void 0) {
+    if (typeof handle !== "string" || !handle || handle.length > MAX_HANDLE_LENGTH) {
+      return null;
+    }
+    resolvedHandle = handle;
+  }
+  let endpointUrl = new URL(request.url);
+  let routeUrl = new URL(endpointUrl.origin);
+  routeUrl.pathname = pathname;
+  routeUrl.search = sanitizeRouteContextSearch(rawSearch);
+  let canonicalPathname = routeUrl.pathname;
+  let searchParams = routeUrl.searchParams;
+  let lastParam2 = (key) => {
+    let values = searchParams.getAll(key);
+    return values.length ? values.at(-1) : void 0;
+  };
+  return {
+    pathname: canonicalPathname,
+    searchParams,
+    url: routeUrl,
+    // Headers come from the actual same-origin POST, never its JSON body.
+    headers: new Headers(request.headers),
+    ...sanitizedI18n ? { i18n: sanitizedI18n } : {},
+    ...resolvedPageType ? { pageType: resolvedPageType } : {},
+    ...resolvedHandle ? { handle: resolvedHandle } : {},
+    isDesignMode: lastParam2("isDesignMode") === "true",
+    isPreviewMode: lastParam2("isPreviewMode") === "true",
+    isRevisionPreview: searchParams.has("__revisionId"),
+    sectionType: lastParam2("sectionType") || void 0
+  };
+}
+function json(body, status) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: NO_STORE_HEADERS
+  });
+}
+function parseDraftItem(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return null;
+  }
+  let draftItem = payload.draftItem;
+  if (typeof draftItem !== "object" || draftItem === null) {
+    return null;
+  }
+  let { id, type } = draftItem;
+  if (typeof id !== "string" || !id || typeof type !== "string" || !type) {
+    return null;
+  }
+  return draftItem;
+}
+function createWeaverseNextRevalidateHandler(config) {
+  return {
+    POST: async (request) => {
+      let payload;
+      try {
+        payload = await request.json();
+      } catch {
+        return json({ error: "invalid-payload" }, STATUS_BAD_REQUEST);
+      }
+      let draftItem = parseDraftItem(payload);
+      if (!draftItem) {
+        return json({ error: "invalid-payload" }, STATUS_BAD_REQUEST);
+      }
+      let requestContext;
+      let body = payload;
+      if (Object.hasOwn(body, "routeContext")) {
+        let reconstructed = reconstructRouteContext(request, body.routeContext);
+        if (!reconstructed) {
+          return json({ error: "invalid-route-context" }, STATUS_BAD_REQUEST);
+        }
+        requestContext = reconstructed;
+      }
+      let client;
+      try {
+        client = await config.getClient(request, requestContext);
+      } catch (error) {
+        console.error("\u274C Revalidate handler getClient failed.", error);
+        return json({ error: "client-init-failed" }, STATUS_SERVER_ERROR);
+      }
+      let component = client.components.find(
+        (candidate) => candidate?.schema?.type === draftItem.type
+      );
+      if (!component) {
+        return json({ error: "unknown-component-type" }, STATUS_NOT_FOUND);
+      }
+      if (typeof component.loader !== "function") {
+        return json({ error: "missing-loader" }, STATUS_UNPROCESSABLE);
+      }
+      try {
+        let loaderData = await component.loader({
+          data: {
+            ...generateDataFromSchema(component.schema),
+            ...draftItem.data
+          },
+          weaverse: client,
+          context: client.requestContext,
+          commerce: client.commerce
+        });
+        return json({ loaderData: loaderData ?? null }, STATUS_OK);
+      } catch (error) {
+        console.error(
+          "\u274C Item loader revalidation failed.",
+          draftItem.type,
+          draftItem.id,
+          error
+        );
+        return json({ error: "loader-failed" }, STATUS_SERVER_ERROR);
+      }
+    }
+  };
+}
 
 // src/server/server-client.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
 var RANDOM_ID_RADIX = 36;
 var RANDOM_ID_SLICE_START = 2;
+var MAX_CUSTOM_PAGE_PAGES = 100;
 var JSON_HEADERS = {
   "Content-Type": "application/json",
   Accept: "application/json",
@@ -134,6 +346,25 @@ function generateUuid() {
   }
   return `id-${Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_SLICE_START)}`;
 }
+function normalizeWeaverseNextPageAssignment(input) {
+  if (!input || typeof input !== "object") {
+    return;
+  }
+  let { projectId, type, handle, locale, meta } = input;
+  if (typeof projectId !== "string" || typeof type !== "string" || typeof handle !== "string") {
+    return;
+  }
+  let normalized = {
+    projectId,
+    type,
+    handle,
+    locale: typeof locale === "string" ? locale : ""
+  };
+  if (meta && typeof meta === "object") {
+    normalized.meta = meta;
+  }
+  return normalized;
+}
 var NextServerClient = class {
   components;
   commerce;
@@ -253,6 +484,59 @@ var NextServerClient = class {
       clearTimeout(timeoutId);
     }
   };
+  _buildCustomPagesUrl(projectId, options, cursor) {
+    let params = new URLSearchParams();
+    if (options.locale) {
+      params.set("locale", options.locale);
+    }
+    if (options.limit) {
+      params.set("limit", String(options.limit));
+    }
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    let qs = params.toString();
+    return `${this._baseConfigs.weaverseApiBase}/api/public/v1/projects/${projectId}/custom-pages${qs ? `?${qs}` : ""}`;
+  }
+  /**
+   * Fetch all published custom pages for sitemap generation. Mirrors Hydrogen's
+   * helper but uses Next's fetch cache knobs (`revalidate` / `tags`). It returns
+   * accumulated results on partial pagination failure so a single API hiccup
+   * does not break sitemap generation entirely.
+   */
+  fetchCustomPages = async (options = {}) => {
+    let projectId = await this.resolveProjectId();
+    let entries = [];
+    if (!projectId) {
+      console.warn(
+        "[WeaverseNext] Failed to fetch custom pages: missing projectId"
+      );
+      return entries;
+    }
+    let cursor = null;
+    for (let page = 0; page < MAX_CUSTOM_PAGE_PAGES; page += 1) {
+      let url = this._buildCustomPagesUrl(projectId, options, cursor);
+      try {
+        let result = await this.fetchWithCache(url, {
+          revalidate: options.revalidate,
+          tags: options.tags
+        });
+        entries.push(...result.data ?? []);
+        if (!result.nextCursor) {
+          return entries;
+        }
+        cursor = result.nextCursor;
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          entries.length === 0 ? `[WeaverseNext] Failed to fetch custom pages: ${message}` : `[WeaverseNext] Custom pages pagination interrupted: ${message}`
+        );
+        return entries;
+      }
+    }
+    console.warn("[WeaverseNext] Custom pages pagination cap reached");
+    return entries;
+  };
   _generateFallbackPage(message) {
     let rootId = generateUuid();
     return {
@@ -380,7 +664,9 @@ var NextServerClient = class {
     this._assertNoPageError(payload);
     let page = payload.page;
     let project = payload.project;
-    let pageAssignment = payload.pageAssignment;
+    let pageAssignment = normalizeWeaverseNextPageAssignment(
+      payload.pageAssignment
+    );
     page ??= this._generateFallbackPage(
       '<div style="text-align: center;">Please add new section to start.</div>'
     );
@@ -436,12 +722,58 @@ var NextServerClient = class {
       return null;
     }
   };
+  /**
+   * Resolve the request locale (e.g. `fr-ca`) used for merchant overrides.
+   * Unlike Hydrogen — which defaults to `en`/`us` because a Hydrogen
+   * storefront always has an i18n context — Next apps may not thread one
+   * through, so a missing language or country means "no explicit locale" and
+   * the translation fetch is skipped rather than guessed.
+   */
+  _resolveOverridesLocale() {
+    let i18n = this.requestContext?.i18n;
+    let language = typeof i18n?.language === "string" ? i18n.language.trim() : "";
+    let country = typeof i18n?.country === "string" ? i18n.country.trim() : "";
+    if (!(language && country)) {
+      return;
+    }
+    return `${language.toLowerCase()}-${country.toLowerCase()}`;
+  }
+  /**
+   * Fetch locale-specific static-text overrides from the translation API.
+   * Ported from Hydrogen's `fetchMerchantOverrides`: skipped entirely when the
+   * theme has no `i18n` schema (nothing translatable) or when the request has
+   * no explicit locale, and never allowed to fail theme settings.
+   */
+  async _fetchMerchantOverrides(projectId, options) {
+    let { weaverseHost } = this._baseConfigs;
+    if (!(asThemeSchema(this.themeSchema)?.i18n && projectId && weaverseHost)) {
+      return;
+    }
+    let locale = this._resolveOverridesLocale();
+    if (!locale) {
+      return;
+    }
+    let url = `${weaverseHost}/api/translation/static?projectId=${projectId}&locale=${locale}`;
+    try {
+      let overrides = await this.fetchWithCache(url, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        revalidate: options.revalidate,
+        tags: options.tags
+      });
+      return typeof overrides === "object" && overrides !== null ? overrides : void 0;
+    } catch (error) {
+      console.warn(
+        "[WeaverseNext] Unable to load merchant overrides, using theme defaults:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+  }
   loadThemeSettings = async (optionsInput = {}) => {
     let options = optionsInput;
     let themeSchema = asThemeSchema(this.themeSchema);
-    let defaultThemeSettings = generateDataFromSchema(
-      this.themeSchema
-    );
+    let defaultThemeSettings = generateDataFromSchema(this.themeSchema);
     let staticContent = themeSchema?.i18n?.staticContent;
     try {
       let projectId = await this.resolveProjectId();
@@ -450,16 +782,16 @@ var NextServerClient = class {
       }
       let { isDesignMode } = this._baseConfigs;
       let url = `${this._baseConfigs.weaverseApiBase}/api/public/project_configs`;
-      let result = await this.fetchWithCache(
-        url,
-        {
+      let [result, merchantOverrides] = await Promise.all([
+        this.fetchWithCache(url, {
           method: "POST",
           body: JSON.stringify({ projectId, isDesignMode }),
           headers: JSON_HEADERS,
           revalidate: options.revalidate,
           tags: options.tags
-        }
-      );
+        }),
+        this._fetchMerchantOverrides(projectId, options)
+      ]);
       if (typeof result !== "object" || result === null) {
         result = { theme: defaultThemeSettings };
       }
@@ -473,21 +805,25 @@ var NextServerClient = class {
       if (staticContent) {
         result.staticContent = staticContent;
       }
+      if (merchantOverrides) {
+        result.merchantOverrides = merchantOverrides;
+      }
       if (isDesignMode) {
+        let serializableSchema = themeSchema ? {
+          ...themeSchema,
+          settings: themeSchema.settings?.map((group) => ({
+            ...group,
+            inputs: group?.inputs?.map(
+              (inputItem) => typeof inputItem?.condition === "function" ? {
+                ...inputItem,
+                condition: inputItem.condition.toString()
+              } : inputItem
+            )
+          }))
+        } : void 0;
         result = {
           ...result,
-          schema: themeSchema ? {
-            ...themeSchema,
-            settings: themeSchema.settings?.map((group) => ({
-              ...group,
-              inputs: group?.inputs?.map(
-                (inputItem) => typeof inputItem?.condition === "function" ? {
-                  ...inputItem,
-                  condition: inputItem.condition.toString()
-                } : inputItem
-              )
-            }))
-          } : void 0,
+          schema: serializableSchema,
           publicEnv: this._baseConfigs.publicEnv
         };
       }
@@ -508,6 +844,6 @@ function createWeaverseNextServerClient(config) {
   return new NextServerClient(config);
 }
 
-export { createWeaverseNextServerClient, getWeaverseNextConfigs, normalizeNextPageUrl, resolveRequestUrl };
+export { createWeaverseNextRevalidateHandler, createWeaverseNextServerClient, getWeaverseNextConfigs, normalizeNextPageUrl, resolveRequestUrl };
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map