@decocms/start 1.6.2 → 1.6.3

package/scripts/migrate/templates/commerce-loaders.ts

@@ -1,4 +1,6 @@
 import type { MigrationContext } from "../types.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
 
 function hasLoaderByName(ctx: MigrationContext, name: string): boolean {
   return ctx.loaderInventory.some(
@@ -6,27 +8,78 @@ function hasLoaderByName(ctx: MigrationContext, name: string): boolean {
   );
 }
 
+function fileExists(ctx: MigrationContext, relPath: string): boolean {
+  const full = path.join(ctx.sourceDir, relPath);
+  if (fs.existsSync(full)) return true;
+  const src = path.join(ctx.sourceDir, "src", relPath);
+  return fs.existsSync(src);
+}
+
 export function generateCommerceLoaders(ctx: MigrationContext): string {
   const lines: string[] = [];
+  const hasSecrets = fileExists(ctx, "utils/secrets.ts") || fileExists(ctx, "src/utils/secrets.ts");
+  const hasProductReviews = hasLoaderByName(ctx, "reviews/productReviews");
+  const hasBuyTogether = hasLoaderByName(ctx, "product/buyTogether");
+  const hasAutocomplete = hasLoaderByName(ctx, "intelligenseSearch") || hasLoaderByName(ctx, "intelligentSearch");
+  const hasVtexAuth = hasLoaderByName(ctx, "vtex-auth-loader");
+  const hasCollectionPLP = hasLoaderByName(ctx, "productListPageCollection");
+  const hasStores = hasLoaderByName(ctx, "stores");
+  const hasProductCard = hasLoaderByName(ctx, "Layouts/ProductCard");
+  const hasSitename = fileExists(ctx, "utils/sitename.ts") || fileExists(ctx, "src/utils/sitename.ts");
 
   lines.push(`/**`);
   lines.push(` * Commerce Loaders — data fetchers registered for CMS block resolution.`);
   lines.push(` *`);
   lines.push(` * Standard VTEX loaders come from createVtexCommerceLoaders().`);
-  lines.push(` * Custom loaders use dynamic imports to the migrated loader files.`);
+  lines.push(` * Auto-generated pass-throughs come from loaders.gen.ts.`);
+  lines.push(` * This file only contains entries that need custom wiring`);
+  lines.push(` * (cookie injection, secrets, serialization, etc.).`);
   lines.push(` */`);
 
   if (ctx.platform === "vtex") {
+    lines.push(`import { getVtexConfig } from "@decocms/apps/vtex";`);
     lines.push(`import { createVtexCommerceLoaders, createCachedPDPLoader } from "@decocms/apps/vtex/commerceLoaders";`);
-    lines.push(`import { createCachedLoader } from "@decocms/start/sdk/cachedLoader";`);
-    lines.push(`import { createAddressFromRequest, updateAddressFromRequest, deleteAddressFromRequest } from "@decocms/apps/vtex/actions/address";`);
+    if (hasAutocomplete) {
+      lines.push(`import { autocompleteSearch } from "@decocms/apps/vtex/loaders/autocomplete";`);
+    }
     lines.push(`import { getAddressByPostalCode } from "@decocms/apps/vtex/loaders/address";`);
-    lines.push(`import { updateProfileFromRequest, newsletterProfileFromRequest } from "@decocms/apps/vtex/actions/profile";`);
-    lines.push(`import { deletePaymentFromRequest } from "@decocms/apps/vtex/actions/payments";`);
-    lines.push(`import { getPasswordLastUpdate } from "@decocms/apps/vtex/loaders/profile";`);
+    lines.push(`import { createAddressFromRequest, updateAddressFromRequest, deleteAddressFromRequest } from "@decocms/apps/vtex/actions/address";`);
+    lines.push(`import { updateProfileFromRequest, newsletterProfileFromRequest, deletePaymentFromRequest, getPasswordLastUpdate } from "@decocms/apps/vtex/actions/profile";`);
+    lines.push(`import { createCachedLoader } from "@decocms/start/sdk/cachedLoader";`);
+
+    if (hasVtexAuth) {
+      lines.push(`import vtexAuthLoader from "../loaders/vtex-auth-loader";`);
+    }
+    if (hasProductReviews) {
+      lines.push(`import productReviewsLoader from "../loaders/reviews/productReviews";`);
+    }
+    if (hasBuyTogether) {
+      lines.push(`import buyTogetherLoader from "../loaders/product/buyTogether";`);
+    }
+    if (hasSecrets) {
+      lines.push(`import { secrets } from "../utils/secrets";`);
+    }
+    if (hasSitename && hasCollectionPLP) {
+      lines.push(`import { useAccount } from "../utils/sitename";`);
+    }
+
+    // Always import siteLoaders — the generate:loaders script creates this file
+    lines.push(`import { siteLoaders } from "../server/cms/loaders.gen";`);
+    lines.push(``);
+
+    lines.push(`const DOMAIN_RE = /;\\s*domain=[^;]*/gi;`);
     lines.push(``);
     lines.push(`export const vtexLoaders = createVtexCommerceLoaders();`);
     lines.push(`export const cachedPDP = createCachedPDPLoader();`);
+
+    if (hasCollectionPLP) {
+      lines.push(`const cachedPLP = vtexLoaders["vtex/loaders/intelligentSearch/productListingPage.ts"];`);
+    }
+    if (hasAutocomplete) {
+      lines.push(`const cachedAutocomplete = createCachedLoader("vtex/autocomplete", autocompleteSearch, "search");`);
+    }
+
+    lines.push(``);
     lines.push(``);
   }
 
@@ -34,88 +87,140 @@ export function generateCommerceLoaders(ctx: MigrationContext): string {
 
   if (ctx.platform === "vtex") {
     lines.push(`  ...vtexLoaders,`);
+    lines.push(`  ...siteLoaders,`);
     lines.push(``);
 
-    // Generic VTEX address actions
-    lines.push(`  // VTEX Address CRUD`);
-    lines.push(`  "vtex/actions/address/createAddress": createAddressFromRequest,`);
-    lines.push(`  "vtex/actions/address/updateAddress": updateAddressFromRequest,`);
-    lines.push(`  "vtex/actions/address/deleteAddress": deleteAddressFromRequest,`);
-    lines.push(`  "vtex/loaders/address/getAddressByZIP": async (props: any) => {`);
-    lines.push(`    return getAddressByPostalCode(props.countryCode ?? "BRA", props.postalCode);`);
-    lines.push(`  },`);
-    lines.push(``);
-
-    // Generic VTEX profile actions
-    lines.push(`  // VTEX Profile actions`);
-    lines.push(`  "vtex/actions/profile/updateProfile": updateProfileFromRequest,`);
-    lines.push(`  "vtex/actions/profile/updateProfile.ts": updateProfileFromRequest,`);
-    lines.push(`  "vtex/actions/profile/newsletterProfile": newsletterProfileFromRequest,`);
-    lines.push(`  "vtex/actions/profile/newsletterProfile.ts": newsletterProfileFromRequest,`);
-    lines.push(``);
+    // Autocomplete aliases
+    if (hasAutocomplete) {
+      lines.push(`  // Autocomplete search — from @decocms/apps`);
+      lines.push(`  "site/loaders/search/intelligenseSearch.ts": cachedAutocomplete,`);
+      lines.push(`  "site/loaders/search/intelligenseSearch": cachedAutocomplete,`);
+      lines.push(``);
+    }
 
-    // Generic VTEX payment actions
-    lines.push(`  // VTEX Payment actions`);
-    lines.push(`  "vtex/actions/payments/delete": deletePaymentFromRequest,`);
-    lines.push(``);
+    // Stores pass-through
+    if (hasStores) {
+      lines.push(`  // Stores pass-through`);
+      lines.push(`  "site/loaders/stores.ts": async (props: any) => {`);
+      lines.push(`    const result = props.stores ?? props ?? [];`);
+      lines.push(`    return Array.isArray(result) ? result : [];`);
+      lines.push(`  },`);
+      lines.push(``);
+    }
 
-    // Generic VTEX profile loaders
-    lines.push(`  // VTEX Profile loaders`);
-    lines.push(`  "vtex/loaders/profile/passwordLastUpdate": getPasswordLastUpdate,`);
+    // VTEX address CRUD
+    lines.push(`  // VTEX address CRUD — request-aware wrappers from @decocms/apps`);
+    lines.push(`  "vtex/actions/address/createAddress": createAddressFromRequest as any,`);
+    lines.push(`  "vtex/actions/address/updateAddress": updateAddressFromRequest as any,`);
+    lines.push(`  "vtex/actions/address/deleteAddress": deleteAddressFromRequest as any,`);
+    lines.push(`  "vtex/loaders/address/getAddressByZIP": async (props: any) => {`);
+    lines.push(`    return getAddressByPostalCode(props.countryCode, props.postalCode);`);
+    lines.push(`  },`);
     lines.push(``);
 
-    // Auth cookie stripping wrapper
-    if (hasLoaderByName(ctx, "vtex-auth-loader")) {
-      lines.push(`  // Auth loader with cookie domain stripping for Workers`);
+    // Auth cookie stripping
+    if (hasVtexAuth) {
+      lines.push(`  // VTEX auth (Set-Cookie forwarding)`);
       lines.push(`  "site/loaders/vtex-auth-loader": async (props: any) => {`);
-      lines.push(`    const mod = await import("../loaders/vtex-auth-loader");`);
-      lines.push(`    const result = await mod.default(props);`);
+      lines.push(`    const result = await vtexAuthLoader(props);`);
       lines.push(`    if (result instanceof Response) {`);
-      lines.push(`      const headers = new Headers(result.headers);`);
-      lines.push(`      const cookies = headers.getSetCookie?.() ?? [];`);
-      lines.push(`      const stripped = cookies.map((c: string) => c.replace(/Domain=[^;]*/i, ""));`);
-      lines.push(`      headers.delete("Set-Cookie");`);
-      lines.push(`      stripped.forEach((c: string) => headers.append("Set-Cookie", c));`);
-      lines.push(`      return new Response(result.body, { status: result.status, headers });`);
+      lines.push(`      const setCookies = result.headers.getSetCookie?.() ?? [];`);
+      lines.push(`      const strippedCookies = setCookies.map((c) => c.replace(DOMAIN_RE, ""));`);
+      lines.push(`      const body = await result.text();`);
+      lines.push(`      const headers = new Headers({ "Content-Type": "application/json" });`);
+      lines.push(`      for (const cookie of strippedCookies) {`);
+      lines.push(`        headers.append("Set-Cookie", cookie);`);
+      lines.push(`      }`);
+      lines.push(`      return new Response(body, { status: result.status, headers });`);
       lines.push(`    }`);
       lines.push(`    return result;`);
       lines.push(`  },`);
       lines.push(``);
     }
 
-    // Cached autocomplete alias
-    if (hasLoaderByName(ctx, "intelligenseSearch") || hasLoaderByName(ctx, "intelligentSearch")) {
-      lines.push(`  // Cached autocomplete search alias`);
-      lines.push(`  "site/loaders/search/intelligenseSearch.ts": createCachedLoader(`);
-      lines.push(`    "vtex/autocomplete",`);
-      lines.push(`    vtexLoaders["vtex/loaders/intelligentSearch/autocomplete"] as any,`);
-      lines.push(`    "search",`);
-      lines.push(`  ),`);
-      lines.push(``);
+    // ProductCard dynamic import
+    if (hasProductCard) {
+      lines.push(`  // CMS-referenced site loaders`);
+      lines.push(`  "site/loaders/Layouts/ProductCard.tsx": async (props: any) => {`);
+      lines.push(`    const mod = await import("../loaders/Layouts/ProductCard");`);
+      lines.push(`    return mod.default(props);`);
+      lines.push(`  },`);
     }
-  }
-
-  // Add custom loaders from inventory
-  for (const loader of ctx.loaderInventory) {
-    if (!loader.isCustom) continue;
 
-    const siteKey = `site/${loader.path}`;
-    const importPath = `../${loader.path}`.replace(/\.tsx?$/, "");
+    // Reviews with secrets
+    if (hasProductReviews) {
+      lines.push(`  "site/loaders/reviews/productReviews.ts": async (props: any) => {`);
+      lines.push(`    const { account } = getVtexConfig();`);
+      lines.push(`    const result = await productReviewsLoader(props, null as any, { account${hasSecrets ? ", ...secrets" : ""} } as any);`);
+      lines.push(`    if (!result) return result;`);
+      lines.push(`    const { getProductReview: _r, reviewLikeAction: _l, reviewVote: _v, getProductsListReviews: _p, ...serializable } = result as any;`);
+      lines.push(`    return serializable;`);
+      lines.push(`  },`);
+    }
 
-    lines.push(`  // Custom: ${loader.path}`);
-    lines.push(`  "${siteKey}": async (props: any) => {`);
-    lines.push(`    const mod = await import("${importPath}");`);
-    lines.push(`    return mod.default(props);`);
-    lines.push(`  },`);
+    // BuyTogether with secrets
+    if (hasBuyTogether) {
+      lines.push(`  "site/loaders/product/buyTogether.ts": async (props: any) => {`);
+      lines.push(`    const { account } = getVtexConfig();`);
+      lines.push(`    return buyTogetherLoader(props, null as any, { account${hasSecrets ? ", ...secrets" : ""} } as any);`);
+      lines.push(`  },`);
+    }
 
-    // Also add without extension
-    const siteKeyNoExt = siteKey.replace(/\.tsx?$/, "");
-    if (siteKeyNoExt !== siteKey) {
-      lines.push(`  "${siteKeyNoExt}": async (props: any) => {`);
-      lines.push(`    const mod = await import("${importPath}");`);
-      lines.push(`    return mod.default(props);`);
+    // Collection PLP
+    if (hasCollectionPLP && hasSitename) {
+      lines.push(``);
+      lines.push(`  // Collection PLP`);
+      lines.push(`  "site/loaders/search/productListPageCollection.ts": async (props: any) => {`);
+      lines.push(`    const url = new URL(props.__pageUrl || props.__pagePath || "/", "https://localhost");`);
+      lines.push(`    const { search_collection_urls_cvlb } = await import("../utils/search-collection-url-cvlb");`);
+      lines.push(`    const { createBreadcrumbFromPath } = await import("../utils/plpHelpers/plpCollection");`);
+      lines.push(`    const { an: accountName } = useAccount();`);
+      lines.push(`    const collections = search_collection_urls_cvlb[accountName] ?? [];`);
+      lines.push(``);
+      lines.push(`    const normalize = (t: string) =>`);
+      lines.push(`      t.normalize("NFD").replace(/[\\u0300-\\u036f]/g, "").toLowerCase()`);
+      lines.push(`        .replace(/[^a-z0-9\\s-]/g, "").replace(/\\s+/g, "-").replace(/-+/g, "-");`);
+      lines.push(``);
+      lines.push(`    const slug = decodeURIComponent(url.pathname.split("/").pop() ?? "").replace(/-/g, " ");`);
+      lines.push(`    const now = Date.now();`);
+      lines.push(`    const collection = collections.find((c: any) =>`);
+      lines.push(`      normalize(c.name) === normalize(slug) &&`);
+      lines.push(`      new Date(c.dateFrom).getTime() <= now &&`);
+      lines.push(`      now <= new Date(c.dateTo).getTime()`);
+      lines.push(`    );`);
+      lines.push(`    if (!collection) return null;`);
+      lines.push(``);
+      lines.push(`    const collectionId = String(collection.id);`);
+      lines.push(`    const response = await cachedPLP({`);
+      lines.push(`      ...props,`);
+      lines.push(`      selectedFacets: [{ key: "productClusterIds", value: collectionId }],`);
+      lines.push(`      __pageUrl: url.toString(),`);
+      lines.push(`      __pagePath: url.pathname,`);
+      lines.push(`    });`);
+      lines.push(`    if (!response) return null;`);
+      lines.push(``);
+      lines.push(`    return {`);
+      lines.push(`      ...response,`);
+      lines.push(`      breadcrumb: createBreadcrumbFromPath(url.pathname, url, collection.name) ?? {},`);
+      lines.push(`      seo: {`);
+      lines.push(`        title: collection.name,`);
+      lines.push(`        description: "O melhor site de compras online para sua casa: compre itens de cozinha, móveis para sala e escritório, acessórios de tecnologia e mais. Clique já!",`);
+      lines.push(`        noIndexing: false,`);
+      lines.push(`        canonical: url.toString(),`);
+      lines.push(`      },`);
+      lines.push(`    };`);
       lines.push(`  },`);
     }
+
+    lines.push(``);
+    // Profile actions
+    lines.push(`  // Profile actions — request-aware wrappers from @decocms/apps`);
+    lines.push(`  "vtex/actions/profile/updateProfile": updateProfileFromRequest as any,`);
+    lines.push(`  "vtex/actions/profile/updateProfile.ts": updateProfileFromRequest as any,`);
+    lines.push(`  "vtex/actions/profile/newsletterProfile": newsletterProfileFromRequest as any,`);
+    lines.push(`  "vtex/actions/profile/newsletterProfile.ts": newsletterProfileFromRequest as any,`);
+    lines.push(`  "vtex/actions/payments/delete": deletePaymentFromRequest as any,`);
+    lines.push(`  "vtex/loaders/profile/passwordLastUpdate": getPasswordLastUpdate as any,`);
   }
 
   lines.push(`};`);

package/scripts/migrate/templates/lib-utils.ts

@@ -0,0 +1,255 @@
+import type { MigrationContext } from "../types.ts";
+
+/**
+ * Generates src/lib/ utility wrappers that provide signature-compatible
+ * stubs for VTEX utilities. The old stack (deco-cx/apps) exports functions
+ * with different signatures than @decocms/apps-start, and some types
+ * (VTEXCommerceStable, LabelledFuzzy) don't exist at all. These wrappers
+ * bridge the gap so custom loaders continue to compile and run.
+ */
+export function generateLibUtils(_ctx: MigrationContext): Record<string, string> {
+  return {
+    "src/lib/vtex-transform.ts": LIB_VTEX_TRANSFORM,
+    "src/lib/vtex-intelligent-search.ts": LIB_VTEX_INTELLIGENT_SEARCH,
+    "src/lib/vtex-segment.ts": LIB_VTEX_SEGMENT,
+    "src/lib/http-utils.ts": LIB_HTTP_UTILS,
+    "src/lib/vtex-client.ts": LIB_VTEX_CLIENT,
+    "src/lib/fetch-utils.ts": LIB_FETCH_UTILS,
+    "src/lib/vtex-fetch.ts": LIB_VTEX_FETCH,
+    "src/lib/vtex-id.ts": LIB_VTEX_ID,
+    "src/lib/graphql-utils.ts": LIB_GRAPHQL_UTILS,
+    "src/lib/filter-navigate.ts": LIB_FILTER_NAVIGATE,
+  };
+}
+
+const LIB_VTEX_TRANSFORM = `import type { Product } from "@decocms/apps/commerce/types";
+
+export function toProduct(vtexProduct: any): Product {
+  return vtexProduct as Product;
+}
+`;
+
+const LIB_VTEX_INTELLIGENT_SEARCH = `export function getISCookiesFromBag(_req?: any): Record<string, string> {
+  return {};
+}
+
+export function isFilterParam(key: string): boolean {
+  return key.startsWith("filter.");
+}
+
+export function toPath(facets: { key: string; value: string }[]): string {
+  return facets.map((f) => \`\${f.key}/\${f.value}\`).join("/");
+}
+
+export function withDefaultFacets(
+  facets: { key: string; value: string }[],
+  defaults?: any,
+): { key: string; value: string }[] {
+  if (Array.isArray(defaults)) {
+    return [...defaults, ...facets];
+  }
+  return [...facets];
+}
+
+export function withDefaultParams(
+  params: any,
+  defaults?: Record<string, string>,
+): any {
+  if (params instanceof URLSearchParams) {
+    if (defaults) {
+      for (const [key, value] of Object.entries(defaults)) {
+        if (!params.has(key)) {
+          params.set(key, value);
+        }
+      }
+    }
+    return params;
+  }
+  return { ...params, ...defaults };
+}
+`;
+
+const LIB_VTEX_SEGMENT = `export function getSegmentFromBag(_req?: any): Record<string, unknown> | null {
+  return null;
+}
+
+export function withSegmentCookie(..._args: any[]): any {
+  for (const arg of _args) {
+    if (arg instanceof Headers) {
+      return arg;
+    }
+  }
+  return new Headers();
+}
+`;
+
+const LIB_HTTP_UTILS = `/**
+ * Drop-in replacement for the typed HTTP client from deco-cx/apps.
+ * Supports both simple \`.get(path)\` / \`.post(path, body)\` calls AND
+ * the indexed pattern \`client["GET /api/path"]({params}, {init})\`
+ * used by legacy loaders.
+ */
+export function createHttpClient<_T = any>(options: {
+  base: string;
+  headers?: Record<string, string> | Headers;
+  fetcher?: typeof fetch;
+}) {
+  const base = options.base.replace(/\\/$/, "");
+  const defaultHeaders: Record<string, string> =
+    options.headers instanceof Headers
+      ? Object.fromEntries(options.headers.entries())
+      : (options.headers || {});
+
+  const handler: ProxyHandler<Record<string, unknown>> = {
+    get(_target, prop) {
+      if (prop === "get") {
+        return async <R = any>(path: string, init?: RequestInit): Promise<R> => {
+          const res = await fetch(\`\${base}\${path}\`, {
+            ...init,
+            headers: { ...defaultHeaders, ...(init?.headers as Record<string, string>) },
+          });
+          return res.json();
+        };
+      }
+      if (prop === "post") {
+        return async <R = any>(path: string, body: unknown, init?: RequestInit): Promise<R> => {
+          const res = await fetch(\`\${base}\${path}\`, {
+            method: "POST",
+            ...init,
+            headers: {
+              "Content-Type": "application/json",
+              ...defaultHeaders,
+              ...(init?.headers as Record<string, string>),
+            },
+            body: JSON.stringify(body),
+          });
+          return res.json();
+        };
+      }
+      if (typeof prop === "string" && /^(GET|POST|PUT|PATCH|DELETE)\\s+/.test(prop)) {
+        const spaceIdx = prop.indexOf(" ");
+        const method = prop.slice(0, spaceIdx);
+        let apiPath = prop.slice(spaceIdx + 1);
+
+        return async (params: Record<string, any> = {}, init?: RequestInit) => {
+          const cleanParams = { ...params };
+
+          const starMatch = apiPath.match(/\\*(\\w+)/);
+          if (starMatch) {
+            const paramName = starMatch[1];
+            if (cleanParams[paramName] != null) {
+              apiPath = apiPath.replace(\`*\${paramName}\`, String(cleanParams[paramName]));
+              delete cleanParams[paramName];
+            } else {
+              apiPath = apiPath.replace(/\\/\\*\\w+/, "");
+            }
+          }
+
+          let url = \`\${base}\${apiPath}\`;
+
+          if (method === "GET") {
+            const sp = new URLSearchParams();
+            for (const [k, v] of Object.entries(cleanParams)) {
+              if (v !== undefined && v !== null) sp.set(k, String(v));
+            }
+            const qs = sp.toString();
+            if (qs) url += (url.includes("?") ? "&" : "?") + qs;
+          }
+
+          const fetchInit: RequestInit = {
+            method,
+            ...init,
+            headers: {
+              ...defaultHeaders,
+              ...(init?.headers instanceof Headers
+                ? Object.fromEntries(init.headers.entries())
+                : (init?.headers as Record<string, string>)),
+            },
+            ...(method !== "GET" && Object.keys(cleanParams).length > 0
+              ? { body: JSON.stringify(cleanParams) }
+              : {}),
+          };
+
+          const res = await fetch(url, fetchInit);
+          return { json: () => res.json(), ok: res.ok, status: res.status, headers: res.headers };
+        };
+      }
+      return undefined;
+    },
+  };
+
+  return new Proxy({} as Record<string, unknown>, handler) as any;
+}
+`;
+
+const LIB_VTEX_CLIENT = `export interface VTEXCommerceStable {
+  account: string;
+  environment?: string;
+}
+`;
+
+const LIB_FETCH_UTILS = `export const STALE = {
+  "Cache-Control": "public, max-age=120, stale-while-revalidate=600",
+};
+`;
+
+const LIB_VTEX_FETCH = `export async function fetchSafe(
+  input: string | URL | Request,
+  init?: RequestInit,
+): Promise<Response> {
+  const response = await fetch(input, init);
+  if (!response.ok) {
+    console.error(\`VTEX fetch failed: \${response.status} \${response.statusText}\`);
+  }
+  return response;
+}
+`;
+
+const LIB_VTEX_ID = `export function parseCookie(cookieStr?: string | null): Record<string, string> {
+  if (!cookieStr) return {};
+  return Object.fromEntries(
+    cookieStr.split(";").map((c) => {
+      const [key, ...rest] = c.trim().split("=");
+      return [key, rest.join("=")];
+    }),
+  );
+}
+`;
+
+const LIB_GRAPHQL_UTILS = `export function createGraphqlClient(options: {
+  endpoint: string;
+  headers?: Record<string, string>;
+}) {
+  return {
+    async query<T = any>(query: string, variables?: Record<string, unknown>): Promise<T> {
+      const res = await fetch(options.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers,
+        },
+        body: JSON.stringify({ query, variables }),
+      });
+      const json = await res.json();
+      return json.data;
+    },
+  };
+}
+`;
+
+const LIB_FILTER_NAVIGATE = `/**
+ * Converts a VTEX filter URL string (e.g. "?filter.brand=x&filter.price=10:50")
+ * into a clean search string without internal params like \`payload\`.
+ * Returns "" or "?filter.brand=x&..." ready to append to pathname.
+ */
+export function toFilterSearchString(filterUrl: string): string {
+  const str = filterUrl.startsWith("?") ? filterUrl.slice(1) : filterUrl;
+  if (!str) return "";
+
+  const params = new URLSearchParams(str);
+  params.delete("payload");
+
+  const clean = params.toString();
+  return clean ? \`?\${clean}\` : "";
+}
+`;

package/scripts/migrate/templates/package-json.ts

@@ -24,35 +24,43 @@ function getLatestVersion(pkg: string, fallback: string): string {
  */
 function extractNpmDeps(importMap: Record<string, string>): Record<string, string> {
   const deps: Record<string, string> = {};
+  const SKIP_KEYS = new Set([
+    "daisyui", "preact-render-to-string", "simple-git", "fast-json-patch",
+    "postcss", "cssnano", "partytown",
+  ]);
   for (const [key, value] of Object.entries(importMap)) {
-    if (!value.startsWith("npm:")) continue;
     // Skip framework deps we handle ourselves
     if (key.startsWith("preact") || key.startsWith("@preact/")) continue;
     if (key.startsWith("@deco/")) continue;
-    if (key === "daisyui") continue;
-    if (key === "preact-render-to-string") continue;
-    if (key === "simple-git") continue;
-    if (key === "fast-json-patch") continue;
-    if (key === "postcss") continue;
-    if (key === "cssnano") continue;
     if (key.startsWith("@biomejs/")) continue;
-    if (key === "partytown") continue;
-    // Consolidate firebase/* split imports into single "firebase" package
     if (key.startsWith("firebase/")) continue;
+    if (SKIP_KEYS.has(key)) continue;
 
-    const raw = value.slice(4); // remove "npm:"
-    const atIdx = raw.lastIndexOf("@");
-    if (atIdx <= 0) {
-      deps[raw] = "*";
-    } else {
-      const name = raw.slice(0, atIdx);
-      let version = raw.slice(atIdx + 1);
-      // Don't double-prefix with ^ if version already has a range prefix
-      if (/^[~^>=<]/.test(version)) {
-        deps[name] = version;
+    // npm: protocol — direct npm import
+    if (value.startsWith("npm:")) {
+      const raw = value.slice(4);
+      const atIdx = raw.lastIndexOf("@");
+      if (atIdx <= 0) {
+        deps[raw] = "*";
       } else {
-        deps[name] = `^${version}`;
+        const name = raw.slice(0, atIdx);
+        let version = raw.slice(atIdx + 1);
+        if (/^[~^>=<]/.test(version)) {
+          deps[name] = version;
+        } else {
+          deps[name] = `^${version}`;
+        }
       }
+      continue;
+    }
+
+    // esm.sh URLs — extract package name and version
+    const esmMatch = value.match(/esm\.sh\/(@?[^@?]+)@([^?/]+)/);
+    if (esmMatch) {
+      const [, name, version] = esmMatch;
+      if (name.startsWith("preact") || name.startsWith("@preact/")) continue;
+      deps[name] = `^${version}`;
+      continue;
     }
   }
   return deps;
@@ -97,9 +105,9 @@ export function generatePackageJson(ctx: MigrationContext): string {
         "tsx node_modules/@decocms/start/scripts/generate-invoke.ts",
       "generate:sections":
         "tsx node_modules/@decocms/start/scripts/generate-sections.ts",
-      "generate:loaders": `tsx node_modules/@decocms/start/scripts/generate-loaders.ts --exclude vtex/loaders,vtex/actions`,
+      "generate:loaders": `tsx node_modules/@decocms/start/scripts/generate-loaders.ts --exclude vtex/loaders,vtex/actions,loaders/vtex-auth-loader,loaders/reviews/productReviews,loaders/product/buyTogether,loaders/search/productListPageCollection,loaders/search/intelligenseSearch,loaders/Layouts/ProductCard`,
       build:
-        "npm run generate:blocks && npm run generate:schema && npm run generate:sections && npm run generate:loaders && tsr generate && vite build",
+        "npm run generate:blocks && npm run generate:sections && npm run generate:loaders && npm run generate:schema && npm run generate:invoke && tsr generate && vite build",
       preview: "vite preview",
       deploy: "npm run build && wrangler deploy",
       types: "wrangler types",