@decocms/start 1.2.6 → 1.2.8

package/scripts/migrate/templates/cache-config.ts

@@ -0,0 +1,26 @@
+import type { MigrationContext } from "../types.ts";
+
+export function generateCacheConfig(ctx: MigrationContext): string {
+  if (ctx.platform !== "vtex") {
+    return `/**
+ * Cache configuration — customize edge cache profiles per route type.
+ * See @decocms/start/sdk/cacheHeaders for available profiles.
+ */
+// import { setCacheProfile } from "@decocms/start/sdk/cacheHeaders";
+// setCacheProfile("product", { sMaxAge: 300, staleWhileRevalidate: 600 });
+`;
+  }
+
+  return `/**
+ * Cache configuration for VTEX storefront.
+ * Overrides default cache profiles from @decocms/start/sdk/cacheHeaders.
+ */
+// import { setCacheProfile } from "@decocms/start/sdk/cacheHeaders";
+
+// Uncomment and adjust as needed:
+// setCacheProfile("product", { sMaxAge: 300, staleWhileRevalidate: 600 });
+// setCacheProfile("listing", { sMaxAge: 120, staleWhileRevalidate: 300 });
+// setCacheProfile("search", { sMaxAge: 60, staleWhileRevalidate: 120 });
+// setCacheProfile("static", { sMaxAge: 86400, staleWhileRevalidate: 172800 });
+`;
+}

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

@@ -0,0 +1,124 @@
+import type { MigrationContext } from "../types.ts";
+
+function hasLoaderByName(ctx: MigrationContext, name: string): boolean {
+  return ctx.loaderInventory.some(
+    (l) => l.path.toLowerCase().includes(name.toLowerCase()),
+  );
+}
+
+export function generateCommerceLoaders(ctx: MigrationContext): string {
+  const lines: string[] = [];
+
+  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(` */`);
+
+  if (ctx.platform === "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";`);
+    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(``);
+    lines.push(`export const vtexLoaders = createVtexCommerceLoaders();`);
+    lines.push(`export const cachedPDP = createCachedPDPLoader();`);
+    lines.push(``);
+  }
+
+  lines.push(`export const COMMERCE_LOADERS: Record<string, (props: any) => Promise<any>> = {`);
+
+  if (ctx.platform === "vtex") {
+    lines.push(`  ...vtexLoaders,`);
+    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(``);
+
+    // Generic VTEX payment actions
+    lines.push(`  // VTEX Payment actions`);
+    lines.push(`  "vtex/actions/payments/delete": deletePaymentFromRequest,`);
+    lines.push(``);
+
+    // Generic VTEX profile loaders
+    lines.push(`  // VTEX Profile loaders`);
+    lines.push(`  "vtex/loaders/profile/passwordLastUpdate": getPasswordLastUpdate,`);
+    lines.push(``);
+
+    // Auth cookie stripping wrapper
+    if (hasLoaderByName(ctx, "vtex-auth-loader")) {
+      lines.push(`  // Auth loader with cookie domain stripping for Workers`);
+      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(`    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(`    }`);
+      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(``);
+    }
+  }
+
+  // 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?$/, "");
+
+    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(`  },`);
+
+    // 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);`);
+      lines.push(`  },`);
+    }
+  }
+
+  lines.push(`};`);
+
+  return lines.join("\n") + "\n";
+}

package/scripts/migrate/templates/hooks.ts

@@ -0,0 +1,358 @@
+import type { MigrationContext } from "../types.ts";
+
+export function generateHooks(ctx: MigrationContext): Record<string, string> {
+  const files: Record<string, string> = {};
+
+  if (ctx.platform === "vtex") {
+    files["src/hooks/useCart.ts"] = generateVtexUseCart();
+  } else {
+    files["src/hooks/useCart.ts"] = generateGenericUseCart();
+  }
+
+  files["src/hooks/useUser.ts"] = generateUseUser();
+  files["src/hooks/useWishlist.ts"] = generateUseWishlist();
+
+  return files;
+}
+
+function generateVtexUseCart(): string {
+  return `import { useState, useEffect } from "react";
+import { invoke } from "~/server/invoke";
+import type { OrderForm, OrderFormItem } from "@decocms/apps/vtex/types";
+
+export type { OrderForm, OrderFormItem };
+
+let _orderForm: OrderForm | null = null;
+let _loading = false;
+let _initStarted = false;
+let _initFailed = false;
+const _listeners = new Set<() => void>();
+
+function notify() {
+  _listeners.forEach((fn) => fn());
+}
+function setOrderForm(of: OrderForm | null) {
+  _orderForm = of;
+  notify();
+}
+function setLoading(v: boolean) {
+  _loading = v;
+  notify();
+}
+
+function getOrderFormIdFromCookie(): string | null {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(/checkout\\.vtex\\.com__orderFormId=([^;]*)/);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+
+function setOrderFormIdCookie(id: string) {
+  if (typeof document === "undefined") return;
+  document.cookie = \`checkout.vtex.com__orderFormId=\${encodeURIComponent(id)}; path=/; max-age=\${7 * 24 * 3600}; SameSite=Lax\`;
+}
+
+async function ensureOrderForm(): Promise<string> {
+  if (_orderForm?.orderFormId) return _orderForm.orderFormId;
+
+  const existing = getOrderFormIdFromCookie();
+  const of = await invoke.vtex.actions.getOrCreateCart({
+    data: { orderFormId: existing || undefined },
+  });
+  setOrderForm(of);
+  if (of?.orderFormId) setOrderFormIdCookie(of.orderFormId);
+  return of.orderFormId;
+}
+
+export function itemToAnalyticsItem(item: OrderFormItem & { coupon?: string }, index: number) {
+  return {
+    item_id: item.productId,
+    item_group_id: item.productId,
+    item_name: item.name ?? item.skuName ?? "",
+    item_variant: item.skuName,
+    item_brand: item.additionalInfo?.brandName ?? "",
+    price: (item.sellingPrice ?? item.price ?? 0) / 100,
+    discount: Number(((item.listPrice - item.sellingPrice) / 100).toFixed(2)),
+    quantity: item.quantity,
+    coupon: item.coupon,
+    affiliation: item.seller,
+    index,
+  };
+}
+
+export function resetCart() {
+  _orderForm = null;
+  _loading = false;
+  _initStarted = false;
+  _initFailed = false;
+  notify();
+}
+
+export function useCart() {
+  const [, forceRender] = useState(0);
+
+  useEffect(() => {
+    const listener = () => forceRender((n) => n + 1);
+    _listeners.add(listener);
+
+    if (!_orderForm && !_initStarted) {
+      _initStarted = true;
+      const ofId = getOrderFormIdFromCookie();
+      setLoading(true);
+      invoke.vtex.actions
+        .getOrCreateCart({ data: { orderFormId: ofId || undefined } })
+        .then((of: OrderForm) => {
+          setOrderForm(of);
+          if (of?.orderFormId) setOrderFormIdCookie(of.orderFormId);
+        })
+        .catch((err: unknown) => {
+          console.error("[useCart] init failed:", err);
+          if (!_orderForm) {
+            _initFailed = true;
+            notify();
+          }
+        })
+        .finally(() => setLoading(false));
+    }
+
+    return () => {
+      _listeners.delete(listener);
+    };
+  }, []);
+
+  return {
+    cart: {
+      get value() { return _orderForm; },
+      set value(v: OrderForm | null) { setOrderForm(v); },
+    },
+
+    loading: {
+      get value() { return _loading; },
+      set value(v: boolean) { setLoading(v); },
+    },
+
+    initFailed: {
+      get value() { return _initFailed; },
+    },
+
+    addItem: async (params: { id: string; seller: string; quantity?: number }) => {
+      setLoading(true);
+      try {
+        const ofId = await ensureOrderForm();
+        const updated = await invoke.vtex.actions.addItemsToCart({
+          data: {
+            orderFormId: ofId,
+            orderItems: [{ id: params.id, seller: params.seller, quantity: params.quantity ?? 1 }],
+          },
+        });
+        setOrderForm(updated);
+        if (updated?.orderFormId) setOrderFormIdCookie(updated.orderFormId);
+      } catch (err) {
+        console.error("[useCart] addItem failed:", err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+
+    addItems: async (params: {
+      orderItems: Array<{ id: string; seller: string; quantity: number }>;
+    }) => {
+      setLoading(true);
+      try {
+        const ofId = await ensureOrderForm();
+        const updated = await invoke.vtex.actions.addItemsToCart({
+          data: { orderFormId: ofId, orderItems: params.orderItems },
+        });
+        setOrderForm(updated);
+        if (updated?.orderFormId) setOrderFormIdCookie(updated.orderFormId);
+      } catch (err) {
+        console.error("[useCart] addItems failed:", err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+
+    updateItems: async (params: { orderItems: Array<{ index: number; quantity: number }> }) => {
+      const ofId = _orderForm?.orderFormId || getOrderFormIdFromCookie();
+      if (!ofId) return;
+      setLoading(true);
+      try {
+        const updated = await invoke.vtex.actions.updateCartItems({
+          data: { orderFormId: ofId, orderItems: params.orderItems },
+        });
+        setOrderForm(updated);
+      } catch (err) {
+        console.error("[useCart] updateItems failed:", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+
+    removeItem: async (index: number) => {
+      const ofId = _orderForm?.orderFormId || getOrderFormIdFromCookie();
+      if (!ofId) return;
+      setLoading(true);
+      try {
+        const updated = await invoke.vtex.actions.updateCartItems({
+          data: { orderFormId: ofId, orderItems: [{ index, quantity: 0 }] },
+        });
+        setOrderForm(updated);
+      } catch (err) {
+        console.error("[useCart] removeItem failed:", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+
+    addCouponsToCart: async ({ text }: { text: string }) => {
+      const ofId = _orderForm?.orderFormId || getOrderFormIdFromCookie();
+      if (!ofId) return;
+      setLoading(true);
+      try {
+        const updated = await invoke.vtex.actions.addCouponToCart({
+          data: { orderFormId: ofId, text },
+        });
+        setOrderForm(updated);
+      } catch (err) {
+        console.error("[useCart] addCoupon failed:", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+
+    sendAttachment: async (params: { attachment: string; body: Record<string, unknown> }) => {
+      const ofId = _orderForm?.orderFormId || getOrderFormIdFromCookie();
+      if (!ofId) return;
+      setLoading(true);
+      try {
+        const updated = await invoke.vtex.actions.updateOrderFormAttachment({
+          data: {
+            orderFormId: ofId,
+            attachment: params.attachment,
+            body: params.body,
+          },
+        });
+        setOrderForm(updated);
+      } catch (err) {
+        console.error("[useCart] sendAttachment failed:", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+
+    simulate: async (data: {
+      items: Array<{ id: string; quantity: number; seller: string }>;
+      postalCode: string;
+      country: string;
+    }) => {
+      return await invoke.vtex.actions.simulateCart({
+        data: {
+          items: data.items.map((i) => ({
+            id: i.id,
+            quantity: i.quantity,
+            seller: i.seller,
+          })),
+          postalCode: data.postalCode,
+          country: data.country,
+        },
+      });
+    },
+
+    mapItemsToAnalyticsItems: (orderForm: OrderForm | null) => {
+      return (orderForm?.items || []).map((item, index) => itemToAnalyticsItem(item, index));
+    },
+  };
+}
+`;
+}
+
+function generateGenericUseCart(): string {
+  return `/**
+ * Cart Hook stub — implement for your platform.
+ *
+ * Wire invoke calls from ~/server/invoke to your commerce platform's
+ * cart API (addItem, updateItem, getCart, etc.).
+ */
+import { signal } from "~/sdk/signal";
+
+const cart = signal<any>(null);
+const loading = signal(false);
+
+export function useCart() {
+  return {
+    cart,
+    loading,
+    async getCart() {
+      // TODO: Implement for your platform
+      return null;
+    },
+    async addItems(_items: any[]) {
+      // TODO: Implement
+    },
+    async updateItems(_items: any[]) {
+      // TODO: Implement
+    },
+    setCart(newCart: any) {
+      cart.value = newCart;
+    },
+  };
+}
+
+export default useCart;
+`;
+}
+
+function generateUseUser(): string {
+  return `/**
+ * User Hook — wire to invoke.site.loaders for your platform's user API.
+ */
+import { signal } from "~/sdk/signal";
+
+export interface User {
+  "@id": string;
+  email: string;
+  givenName?: string;
+  familyName?: string;
+}
+
+const user = signal<User | null>(null);
+const loading = signal(false);
+
+export function useUser() {
+  return { user, loading };
+}
+
+export default useUser;
+`;
+}
+
+function generateUseWishlist(): string {
+  return `/**
+ * Wishlist Hook — wire to invoke.site.loaders/actions for your platform.
+ *
+ * For VTEX: use invoke.site.loaders.getWishlistItems and
+ *           invoke.site.actions.addWishlistItem / removeWishlistItem.
+ */
+import { signal } from "~/sdk/signal";
+
+const loading = signal(false);
+
+export function useWishlist() {
+  return {
+    loading,
+    async addItem(_productId: string, _productGroupId: string) {
+      // TODO: Implement
+    },
+    async removeItem(_productId: string) {
+      // TODO: Implement
+    },
+    getItem(_productId: string): boolean {
+      return false;
+    },
+  };
+}
+
+export default useWishlist;
+`;
+}

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

@@ -31,8 +31,14 @@ function extractNpmDeps(importMap: Record<string, string>): Record<string, strin
     if (key.startsWith("@deco/")) continue;
     if (key === "daisyui") continue;
     if (key === "preact-render-to-string") continue;
-    if (key === "simple-git") continue; // dev tool, not needed in runtime
-    if (key === "fast-json-patch") continue; // used by old deco runtime
+    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;
 
     const raw = value.slice(4); // remove "npm:"
     const atIdx = raw.lastIndexOf("@");
@@ -53,11 +59,23 @@ function extractNpmDeps(importMap: Record<string, string>): Record<string, strin
 }
 
 export function generatePackageJson(ctx: MigrationContext): string {
-  const siteDeps = {
+  const extractedDeps = {
     ...extractNpmDeps(ctx.importMap),
     ...ctx.discoveredNpmDeps,
   };
 
+  // Consolidate firebase/* split imports into single package
+  const hasFirebase = Object.keys(ctx.importMap).some((k) => k.startsWith("firebase"));
+  if (hasFirebase && !extractedDeps["firebase"]) {
+    extractedDeps["firebase"] = "^12.10.0";
+  }
+  // Remove wildcard versions
+  for (const [k, v] of Object.entries(extractedDeps)) {
+    if (v === "^*" || v === "*") extractedDeps[k] = "latest";
+  }
+
+  const siteDeps = extractedDeps;
+
   // Fetch latest versions from npm registry
   const startVersion = getLatestVersion("@decocms/start", "0.34.0");
   const appsVersion = getLatestVersion("@decocms/apps", "0.27.0");
@@ -75,8 +93,13 @@ export function generatePackageJson(ctx: MigrationContext): string {
         "tsx node_modules/@decocms/start/scripts/generate-blocks.ts",
       "generate:routes": "tsr generate",
       "generate:schema": `tsx node_modules/@decocms/start/scripts/generate-schema.ts --site ${ctx.siteName}`,
+      "generate:invoke":
+        "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`,
       build:
-        "npm run generate:blocks && npm run generate:schema && tsr generate && vite build",
+        "npm run generate:blocks && npm run generate:schema && npm run generate:sections && npm run generate:loaders && tsr generate && vite build",
       preview: "vite preview",
       deploy: "npm run build && wrangler deploy",
       types: "wrangler types",
@@ -87,9 +110,9 @@ export function generatePackageJson(ctx: MigrationContext): string {
       clean:
         "rm -rf node_modules .cache dist .wrangler/state node_modules/.vite && npm install",
       "tailwind:lint":
-        "tsx node_modules/@decocms/start/scripts/tailwind-lint.ts",
+        "tsx scripts/tailwind-lint.ts",
       "tailwind:fix":
-        "tsx node_modules/@decocms/start/scripts/tailwind-lint.ts --fix",
+        "tsx scripts/tailwind-lint.ts --fix",
     },
     author: "deco.cx",
     license: "MIT",