create-brainerce-store 1.18.0 → 1.19.0

package/templates/nextjs/base/src/components/seo/product-json-ld.tsx

@@ -1,72 +1,72 @@
-import type { Product } from 'brainerce';
-import { getProductPriceInfo } from 'brainerce';
-
-interface ProductJsonLdProps {
-  product: Product;
-  url: string;
-  currency?: string;
-}
-
-export function ProductJsonLd({ product, url, currency = 'USD' }: ProductJsonLdProps) {
-  const priceInfo = getProductPriceInfo(product);
-  const imageUrl = product.images?.[0]?.url;
-  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || '';
-
-  const productJsonLd = {
-    '@context': 'https://schema.org',
-    '@type': 'Product',
-    name: product.name,
-    description: product.description || product.name,
-    image: imageUrl,
-    url,
-    sku: product.sku || product.id,
-    offers: {
-      '@type': 'Offer',
-      price: priceInfo.price,
-      priceCurrency: currency,
-      availability:
-        product.inventory?.canPurchase !== false
-          ? 'https://schema.org/InStock'
-          : 'https://schema.org/OutOfStock',
-      url,
-    },
-  };
-
-  const breadcrumbJsonLd = {
-    '@context': 'https://schema.org',
-    '@type': 'BreadcrumbList',
-    itemListElement: [
-      {
-        '@type': 'ListItem',
-        position: 1,
-        name: 'Home',
-        item: baseUrl || '/',
-      },
-      {
-        '@type': 'ListItem',
-        position: 2,
-        name: 'Products',
-        item: `${baseUrl}/products`,
-      },
-      {
-        '@type': 'ListItem',
-        position: 3,
-        name: product.name,
-        item: url,
-      },
-    ],
-  };
-
-  return (
-    <>
-      <script
-        type="application/ld+json"
-        dangerouslySetInnerHTML={{ __html: JSON.stringify(productJsonLd) }}
-      />
-      <script
-        type="application/ld+json"
-        dangerouslySetInnerHTML={{ __html: JSON.stringify(breadcrumbJsonLd) }}
-      />
-    </>
-  );
-}
+import type { Product } from 'brainerce';
+import { getProductPriceInfo } from 'brainerce';
+
+interface ProductJsonLdProps {
+  product: Product;
+  url: string;
+  currency?: string;
+}
+
+export function ProductJsonLd({ product, url, currency = 'USD' }: ProductJsonLdProps) {
+  const priceInfo = getProductPriceInfo(product);
+  const imageUrl = product.images?.[0]?.url;
+  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || '';
+
+  const productJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'Product',
+    name: product.name,
+    description: product.description || product.name,
+    image: imageUrl,
+    url,
+    sku: product.sku || product.id,
+    offers: {
+      '@type': 'Offer',
+      price: priceInfo.price,
+      priceCurrency: currency,
+      availability:
+        product.inventory?.canPurchase !== false
+          ? 'https://schema.org/InStock'
+          : 'https://schema.org/OutOfStock',
+      url,
+    },
+  };
+
+  const breadcrumbJsonLd = {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: [
+      {
+        '@type': 'ListItem',
+        position: 1,
+        name: 'Home',
+        item: baseUrl || '/',
+      },
+      {
+        '@type': 'ListItem',
+        position: 2,
+        name: 'Products',
+        item: `${baseUrl}/products`,
+      },
+      {
+        '@type': 'ListItem',
+        position: 3,
+        name: product.name,
+        item: url,
+      },
+    ],
+  };
+
+  return (
+    <>
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(productJsonLd) }}
+      />
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(breadcrumbJsonLd) }}
+      />
+    </>
+  );
+}

package/templates/nextjs/base/src/i18n.ts.ejs

@@ -1,5 +1,26 @@
+<% if (i18nEnabled) { %>
+// Multi-language store — locales loaded dynamically
+export const defaultLocale = '<%= defaultLocale %>';
+export const supportedLocales = <%- supportedLocales %> as const;
+export type Locale = (typeof supportedLocales)[number];
+
+const RTL_LOCALES = new Set(['he', 'ar']);
+
+export function getDirection(locale: string): 'ltr' | 'rtl' {
+  return RTL_LOCALES.has(locale) ? 'rtl' : 'ltr';
+}
+
+export async function getMessages(locale: string): Promise<Record<string, Record<string, string>>> {
+  try {
+    return (await import(`../messages/${locale}.json`)).default;
+  } catch {
+    return (await import(`../messages/<%= defaultLocale %>.json`)).default;
+  }
+}
+<% } else { %>
 import messages from '../messages/<%= language %>.json';
 
 export const defaultLocale = '<%= language %>';
 export const direction = '<%= direction %>' as 'ltr' | 'rtl';
 export { messages };
+<% } %>

package/templates/nextjs/base/src/lib/auth.ts

@@ -1,149 +1,149 @@
-/**
- * Client-side auth helpers that call the BFF proxy API routes.
- * All mutating requests include the CSRF header.
- * The token is managed server-side via httpOnly cookies — never exposed to JS.
- */
-
-const CONNECTION_ID = process.env.NEXT_PUBLIC_BRAINERCE_CONNECTION_ID || '';
-
-const CSRF_HEADERS: Record<string, string> = {
-  'Content-Type': 'application/json',
-  'X-Requested-With': 'brainerce',
-};
-
-interface LoginResult {
-  customer: {
-    id: string;
-    email: string;
-    firstName?: string;
-    lastName?: string;
-    emailVerified: boolean;
-  };
-  expiresAt: string;
-  requiresVerification?: boolean;
-}
-
-interface RegisterResult {
-  customer: {
-    id: string;
-    email: string;
-    firstName?: string;
-    lastName?: string;
-    emailVerified: boolean;
-  };
-  expiresAt: string;
-  requiresVerification?: boolean;
-}
-
-interface AuthStatus {
-  isLoggedIn: boolean;
-  customer?: {
-    id: string;
-    email: string;
-    firstName?: string;
-    lastName?: string;
-    phone?: string;
-    emailVerified: boolean;
-  };
-  error?: string;
-}
-
-interface VerifyEmailResult {
-  verified: boolean;
-  message?: string;
-}
-
-async function handleResponse<T>(response: Response): Promise<T> {
-  const data = await response.json();
-  if (!response.ok) {
-    throw new Error(data.message || data.error || `Request failed (${response.status})`);
-  }
-  return data as T;
-}
-
-/**
- * Login via BFF proxy. The proxy sets the httpOnly cookie on success.
- */
-export async function proxyLogin(email: string, password: string): Promise<LoginResult> {
-  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/login`, {
-    method: 'POST',
-    headers: CSRF_HEADERS,
-    body: JSON.stringify({ email, password }),
-  });
-  return handleResponse<LoginResult>(response);
-}
-
-/**
- * Register via BFF proxy. The proxy sets the httpOnly cookie on success.
- */
-export async function proxyRegister(data: {
-  firstName: string;
-  lastName: string;
-  email: string;
-  password: string;
-  acceptsMarketing?: boolean;
-}): Promise<RegisterResult> {
-  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/register`, {
-    method: 'POST',
-    headers: CSRF_HEADERS,
-    body: JSON.stringify(data),
-  });
-  return handleResponse<RegisterResult>(response);
-}
-
-/**
- * Check auth status. Reads httpOnly cookie server-side and validates with backend.
- */
-export async function checkAuthStatus(): Promise<AuthStatus> {
-  const response = await fetch('/api/auth/me');
-  return response.json();
-}
-
-/**
- * Logout. Clears httpOnly auth cookies server-side.
- */
-export async function proxyLogout(): Promise<void> {
-  await fetch('/api/auth/logout', {
-    method: 'POST',
-    headers: { 'X-Requested-With': 'brainerce' },
-  });
-}
-
-/**
- * Verify email via BFF proxy. The auth token is in the httpOnly cookie (set during login/register).
- * The proxy adds the Authorization header automatically.
- */
-export async function proxyVerifyEmail(code: string): Promise<VerifyEmailResult> {
-  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/verify-email`, {
-    method: 'POST',
-    headers: CSRF_HEADERS,
-    body: JSON.stringify({ code }),
-  });
-  return handleResponse<VerifyEmailResult>(response);
-}
-
-/**
- * Resend verification email via BFF proxy.
- * Uses the auth token from the httpOnly cookie.
- */
-export async function proxyResendVerification(): Promise<{ message: string }> {
-  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/resend-verification`, {
-    method: 'POST',
-    headers: CSRF_HEADERS,
-  });
-  return handleResponse<{ message: string }>(response);
-}
-
-/**
- * Reset password via BFF proxy.
- * The reset token is in an httpOnly cookie (set by /api/auth/reset-callback when the user
- * clicked the email link). The proxy reads it server-side — the token never reaches client JS.
- */
-export async function proxyResetPassword(newPassword: string): Promise<{ message: string }> {
-  const response = await fetch('/api/auth/reset-password', {
-    method: 'POST',
-    headers: CSRF_HEADERS,
-    body: JSON.stringify({ newPassword }),
-  });
-  return handleResponse<{ message: string }>(response);
-}
+/**
+ * Client-side auth helpers that call the BFF proxy API routes.
+ * All mutating requests include the CSRF header.
+ * The token is managed server-side via httpOnly cookies — never exposed to JS.
+ */
+
+const CONNECTION_ID = process.env.NEXT_PUBLIC_BRAINERCE_CONNECTION_ID || '';
+
+const CSRF_HEADERS: Record<string, string> = {
+  'Content-Type': 'application/json',
+  'X-Requested-With': 'brainerce',
+};
+
+interface LoginResult {
+  customer: {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    emailVerified: boolean;
+  };
+  expiresAt: string;
+  requiresVerification?: boolean;
+}
+
+interface RegisterResult {
+  customer: {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    emailVerified: boolean;
+  };
+  expiresAt: string;
+  requiresVerification?: boolean;
+}
+
+interface AuthStatus {
+  isLoggedIn: boolean;
+  customer?: {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    emailVerified: boolean;
+  };
+  error?: string;
+}
+
+interface VerifyEmailResult {
+  verified: boolean;
+  message?: string;
+}
+
+async function handleResponse<T>(response: Response): Promise<T> {
+  const data = await response.json();
+  if (!response.ok) {
+    throw new Error(data.message || data.error || `Request failed (${response.status})`);
+  }
+  return data as T;
+}
+
+/**
+ * Login via BFF proxy. The proxy sets the httpOnly cookie on success.
+ */
+export async function proxyLogin(email: string, password: string): Promise<LoginResult> {
+  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/login`, {
+    method: 'POST',
+    headers: CSRF_HEADERS,
+    body: JSON.stringify({ email, password }),
+  });
+  return handleResponse<LoginResult>(response);
+}
+
+/**
+ * Register via BFF proxy. The proxy sets the httpOnly cookie on success.
+ */
+export async function proxyRegister(data: {
+  firstName: string;
+  lastName: string;
+  email: string;
+  password: string;
+  acceptsMarketing?: boolean;
+}): Promise<RegisterResult> {
+  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/register`, {
+    method: 'POST',
+    headers: CSRF_HEADERS,
+    body: JSON.stringify(data),
+  });
+  return handleResponse<RegisterResult>(response);
+}
+
+/**
+ * Check auth status. Reads httpOnly cookie server-side and validates with backend.
+ */
+export async function checkAuthStatus(): Promise<AuthStatus> {
+  const response = await fetch('/api/auth/me');
+  return response.json();
+}
+
+/**
+ * Logout. Clears httpOnly auth cookies server-side.
+ */
+export async function proxyLogout(): Promise<void> {
+  await fetch('/api/auth/logout', {
+    method: 'POST',
+    headers: { 'X-Requested-With': 'brainerce' },
+  });
+}
+
+/**
+ * Verify email via BFF proxy. The auth token is in the httpOnly cookie (set during login/register).
+ * The proxy adds the Authorization header automatically.
+ */
+export async function proxyVerifyEmail(code: string): Promise<VerifyEmailResult> {
+  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/verify-email`, {
+    method: 'POST',
+    headers: CSRF_HEADERS,
+    body: JSON.stringify({ code }),
+  });
+  return handleResponse<VerifyEmailResult>(response);
+}
+
+/**
+ * Resend verification email via BFF proxy.
+ * Uses the auth token from the httpOnly cookie.
+ */
+export async function proxyResendVerification(): Promise<{ message: string }> {
+  const response = await fetch(`/api/store/api/vc/${CONNECTION_ID}/customers/resend-verification`, {
+    method: 'POST',
+    headers: CSRF_HEADERS,
+  });
+  return handleResponse<{ message: string }>(response);
+}
+
+/**
+ * Reset password via BFF proxy.
+ * The reset token is in an httpOnly cookie (set by /api/auth/reset-callback when the user
+ * clicked the email link). The proxy reads it server-side — the token never reaches client JS.
+ */
+export async function proxyResetPassword(newPassword: string): Promise<{ message: string }> {
+  const response = await fetch('/api/auth/reset-password', {
+    method: 'POST',
+    headers: CSRF_HEADERS,
+    body: JSON.stringify({ newPassword }),
+  });
+  return handleResponse<{ message: string }>(response);
+}

package/templates/nextjs/base/src/lib/brainerce.ts.ejs

@@ -15,6 +15,15 @@ export function getClient(): BrainerceClient {
   }
   return clientInstance;
 }
+<% if (i18nEnabled) { %>
+
+/** Initialize client with a specific locale for translated content */
+export function initClientWithLocale(locale: string): BrainerceClient {
+  const client = getClient();
+  client.setLocale(locale);
+  return client;
+}
+<% } %>
 
 // Cart ID helpers (not a security token — safe in localStorage)
 const CART_ID_KEY = 'brainerce_cart_id';

package/templates/nextjs/base/src/lib/translations.ts.ejs

@@ -0,0 +1,31 @@
+<% if (i18nEnabled) { %>
+'use client';
+
+import { createContext, useContext } from 'react';
+
+type Messages = Record<string, Record<string, string>>;
+
+const MessagesContext = createContext<Messages>({});
+
+export { MessagesContext };
+
+export function useTranslations(namespace: string) {
+  const messages = useContext(MessagesContext);
+  const ns = (messages[namespace] || {}) as Record<string, string>;
+  return function t(key: string): string {
+    return ns[key] || `${namespace}.${key}`;
+  };
+}
+<% } else { %>
+import { messages } from '@/i18n';
+
+type Messages = typeof messages;
+type Namespace = keyof Messages;
+
+export function useTranslations<N extends Namespace>(namespace: N) {
+  const ns = messages[namespace] as Record<string, string>;
+  return function t(key: keyof Messages[N]): string {
+    return ns[key as string] || `${String(namespace)}.${key as string}`;
+  };
+}
+<% } %>

package/templates/nextjs/base/src/middleware.ts.ejs

@@ -0,0 +1,81 @@
+<% if (i18nEnabled) { %>
+import { NextRequest, NextResponse } from 'next/server';
+
+const TOKEN_COOKIE = 'brainerce_customer_token';
+const PROTECTED_PATHS = ['/account'];
+const supportedLocales = <%- supportedLocales %>;
+const defaultLocale = '<%= defaultLocale %>';
+
+function getLocaleFromPath(pathname: string): string | null {
+  const segment = pathname.split('/')[1];
+  return supportedLocales.includes(segment) ? segment : null;
+}
+
+export function middleware(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  // Skip static files and API routes
+  if (
+    pathname.startsWith('/api/') ||
+    pathname.startsWith('/_next/') ||
+    pathname.includes('.')
+  ) {
+    return NextResponse.next();
+  }
+
+  const pathnameLocale = getLocaleFromPath(pathname);
+
+  // Redirect to default locale if no locale prefix
+  if (!pathnameLocale) {
+    const url = request.nextUrl.clone();
+    url.pathname = `/${defaultLocale}${pathname}`;
+    return NextResponse.redirect(url);
+  }
+
+  // Auth protection (with locale prefix)
+  const pathWithoutLocale = pathname.replace(`/${pathnameLocale}`, '') || '/';
+  const isProtected = PROTECTED_PATHS.some((p) => pathWithoutLocale.startsWith(p));
+  if (isProtected) {
+    const token = request.cookies.get(TOKEN_COOKIE);
+    if (!token?.value) {
+      const loginUrl = new URL(`/${pathnameLocale}/login`, request.url);
+      return NextResponse.redirect(loginUrl);
+    }
+  }
+
+  // Set locale header for server components
+  const response = NextResponse.next();
+  response.headers.set('x-locale', pathnameLocale);
+  return response;
+}
+
+export const config = {
+  matcher: ['/((?!_next|api|.*\\..*).*)'],
+};
+<% } else { %>
+import { NextRequest, NextResponse } from 'next/server';
+
+const TOKEN_COOKIE = 'brainerce_customer_token';
+
+/** Routes that require customer authentication */
+const PROTECTED_PATHS = ['/account'];
+
+export function middleware(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+  const isProtected = PROTECTED_PATHS.some((p) => pathname.startsWith(p));
+
+  if (isProtected) {
+    const token = request.cookies.get(TOKEN_COOKIE);
+    if (!token?.value) {
+      const loginUrl = new URL('/login', request.url);
+      return NextResponse.redirect(loginUrl);
+    }
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/account/:path*'],
+};
+<% } %>