@decocms/start 0.21.1 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/start",
-  "version": "0.21.1",
+  "version": "0.22.1",
   "type": "module",
   "description": "Deco framework for TanStack Start - CMS bridge, admin protocol, hooks, schema generation",
   "main": "./src/index.ts",
@@ -31,6 +31,7 @@
     "./sdk/wrapCaughtErrors": "./src/sdk/wrapCaughtErrors.ts",
     "./sdk/csp": "./src/sdk/csp.ts",
     "./sdk/urlUtils": "./src/sdk/urlUtils.ts",
+    "./sdk/normalizeUrls": "./src/sdk/normalizeUrls.ts",
     "./sdk/mergeCacheControl": "./src/sdk/mergeCacheControl.ts",
     "./sdk/requestContext": "./src/sdk/requestContext.ts",
     "./sdk/createInvoke": "./src/sdk/createInvoke.ts",

package/src/hooks/DecoPageRenderer.tsx

@@ -209,18 +209,21 @@ export function SectionList({ sections }: { sections: Section[] | null | undefin
 interface DeferredSectionWrapperProps {
   deferred: DeferredSection;
   pagePath: string;
+  pageUrl?: string;
   loadingFallback?: ReactNode;
   errorFallback?: ReactNode;
   loadFn: (data: {
     component: string;
     rawProps: Record<string, unknown>;
     pagePath: string;
+    pageUrl?: string;
   }) => Promise<ResolvedSection | null>;
 }
 
 function DeferredSectionWrapper({
   deferred,
   pagePath,
+  pageUrl,
   loadingFallback,
   errorFallback,
   loadFn,
@@ -262,7 +265,7 @@ function DeferredSectionWrapper({
   const skeleton = !optionsReady
     ? null
     : hasCustomFallback
-      ? createElement(loadedOptions!.loadingFallback!)
+      ? createElement(loadedOptions!.loadingFallback!, deferred.rawProps)
       : (loadingFallback ??
         (isDev ? (
           <DevMissingFallbackWarning component={deferred.component} />
@@ -283,6 +286,7 @@ function DeferredSectionWrapper({
         component: deferred.component,
         rawProps: deferred.rawProps,
         pagePath,
+        pageUrl,
       })
         .then((result) => {
           if (result) deferredSectionCache.set(key0, { section: result, ts: Date.now() });
@@ -302,6 +306,7 @@ function DeferredSectionWrapper({
             component: deferred.component,
             rawProps: deferred.rawProps,
             pagePath,
+            pageUrl,
           })
             .then((result) => {
               if (result) deferredSectionCache.set(key1, { section: result, ts: Date.now() });
@@ -315,7 +320,7 @@ function DeferredSectionWrapper({
 
     observer.observe(el);
     return () => observer.disconnect();
-  }, [deferred.component, deferred.rawProps, pagePath, section, loadFn]);
+  }, [deferred.component, deferred.rawProps, pagePath, pageUrl, section, loadFn]);
 
   if (error) {
     const errFallback = loadedOptions?.errorFallback
@@ -403,12 +408,15 @@ interface Props {
   sections: ResolvedSection[];
   deferredSections?: DeferredSection[];
   pagePath?: string;
+  /** Original page URL (with query params) — forwarded to deferred section loaders. */
+  pageUrl?: string;
   loadingFallback?: ReactNode;
   errorFallback?: ReactNode;
   loadDeferredSectionFn?: (data: {
     component: string;
     rawProps: Record<string, unknown>;
     pagePath: string;
+    pageUrl?: string;
   }) => Promise<ResolvedSection | null>;
 }
 
@@ -416,6 +424,7 @@ export function DecoPageRenderer({
   sections,
   deferredSections,
   pagePath = "/",
+  pageUrl,
   loadingFallback,
   errorFallback,
   loadDeferredSectionFn,
@@ -436,6 +445,7 @@ export function DecoPageRenderer({
               key={`deferred-${pagePath}-${item.deferred.key}-${item.deferred.index}`}
               deferred={item.deferred}
               pagePath={pagePath}
+              pageUrl={pageUrl}
               loadingFallback={loadingFallback}
               errorFallback={errorFallback}
               loadFn={loadDeferredSectionFn}

package/src/routes/cmsRoute.ts

@@ -39,6 +39,7 @@ import {
   detectCacheProfile,
   routeCacheDefaults,
 } from "../sdk/cacheHeaders";
+import { normalizeUrlsInObject } from "../sdk/normalizeUrls";
 
 const isServer = typeof document === "undefined";
 
@@ -86,9 +87,10 @@ async function loadCmsPageInternal(fullPath: string) {
   const cacheProfile = detectCacheProfile(basePath);
   return {
     ...page,
-    resolvedSections: enrichedSections,
-    deferredSections: page.deferredSections,
+    resolvedSections: normalizeUrlsInObject(enrichedSections),
+    deferredSections: normalizeUrlsInObject(page.deferredSections),
     cacheProfile,
+    pageUrl: urlWithSearch,
   };
 }
 
@@ -128,8 +130,8 @@ export const loadCmsHomePage = createServerFn({ method: "GET" }).handler(async (
 
   return {
     ...page,
-    resolvedSections: enrichedSections,
-    deferredSections: page.deferredSections,
+    resolvedSections: normalizeUrlsInObject(enrichedSections),
+    deferredSections: normalizeUrlsInObject(page.deferredSections),
   };
 });
 
@@ -140,14 +142,15 @@ export const loadCmsHomePage = createServerFn({ method: "GET" }).handler(async (
 export const loadDeferredSection = createServerFn({ method: "POST" })
   .inputValidator(
     (data: unknown) =>
-      data as { component: string; rawProps: Record<string, any>; pagePath: string },
+      data as { component: string; rawProps: Record<string, any>; pagePath: string; pageUrl?: string },
   )
   .handler(async (ctx) => {
-    const { component, rawProps, pagePath } = ctx.data;
+    const { component, rawProps, pagePath, pageUrl } = ctx.data;
 
+    const serverUrl = getRequestUrl().toString();
     const matcherCtx: MatcherContext = {
       userAgent: getRequestHeader("user-agent") ?? "",
-      url: getRequestUrl().toString(),
+      url: pageUrl || serverUrl,
       path: pagePath,
       cookies: getCookies(),
     };
@@ -155,11 +158,11 @@ export const loadDeferredSection = createServerFn({ method: "POST" })
     const section = await resolveDeferredSection(component, rawProps, pagePath, matcherCtx);
     if (!section) return null;
 
-    const request = new Request(getRequestUrl().toString(), {
+    const request = new Request(pageUrl || serverUrl, {
       headers: getRequest().headers,
     });
     const enriched = await runSingleSectionLoader(section, request);
-    return enriched;
+    return normalizeUrlsInObject(enriched);
   });
 
 // ---------------------------------------------------------------------------

package/src/sdk/index.ts

@@ -27,6 +27,11 @@ export {
 } from "./instrumentedFetch";
 export { batchInvoke, createInvokeProxy, type InvokeProxy, invokeQueryOptions } from "./invoke";
 export { createCacheControlCollector, mergeCacheControl } from "./mergeCacheControl";
+export {
+  getProductionOrigins,
+  normalizeUrlsInObject,
+  registerProductionOrigins,
+} from "./normalizeUrls";
 export {
   addRedirects,
   loadRedirects,

package/src/sdk/normalizeUrls.ts

@@ -0,0 +1,91 @@
+/**
+ * URL normalization for CMS-resolved props.
+ *
+ * Strips registered production origins from absolute URLs, converting them to
+ * relative paths. This allows staging/preview deployments to work without
+ * every CMS-authored link sending users to the production domain.
+ *
+ * Only affects strings that START with a registered origin + "/" — image CDN
+ * URLs, API endpoints on different domains, and non-URL strings are untouched.
+ *
+ * @example
+ * ```ts
+ * // In site's setup.ts:
+ * import { registerProductionOrigins } from "@decocms/start/sdk/normalizeUrls";
+ * registerProductionOrigins([
+ *   "https://www.casaevideo.com.br",
+ *   "https://casaevideo.com.br",
+ * ]);
+ * ```
+ */
+
+let origins: string[] = [];
+
+/**
+ * Register production origins that should be stripped from CMS-resolved URLs.
+ * Call once in your site's setup.ts before any page loads.
+ */
+export function registerProductionOrigins(productionOrigins: string[]) {
+  origins = productionOrigins.map((o) => o.replace(/\/+$/, ""));
+}
+
+export function getProductionOrigins(): readonly string[] {
+  return origins;
+}
+
+function normalizeString(str: string): string {
+  for (const origin of origins) {
+    if (str.startsWith(origin + "/")) {
+      return str.slice(origin.length);
+    }
+    if (str === origin) {
+      return "/";
+    }
+  }
+  return str;
+}
+
+/**
+ * Deep-walk an object tree and rewrite any string value that starts with a
+ * registered production origin to a relative path. Returns the same reference
+ * if nothing was changed (structural sharing).
+ */
+export function normalizeUrlsInObject<T>(obj: T): T {
+  if (!origins.length) return obj;
+  return deepNormalize(obj) as T;
+}
+
+function deepNormalize(val: unknown): unknown {
+  if (val == null) return val;
+
+  if (typeof val === "string") {
+    return normalizeString(val);
+  }
+
+  if (Array.isArray(val)) {
+    let changed = false;
+    const result = val.map((item) => {
+      const normalized = deepNormalize(item);
+      if (normalized !== item) changed = true;
+      return normalized;
+    });
+    return changed ? result : val;
+  }
+
+  if (typeof val === "object") {
+    // Skip React elements, Dates, RegExps, and other non-plain objects
+    const proto = Object.getPrototypeOf(val);
+    if (proto !== Object.prototype && proto !== null) return val;
+
+    let changed = false;
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(val as Record<string, unknown>)) {
+      const normalized = deepNormalize(value);
+      result[key] = normalized;
+      if (normalized !== value) changed = true;
+    }
+    return changed ? result : val;
+  }
+
+  return val;
+}