@fayz-ai/storefront 0.9.0 → 0.11.0

package/src/auth.ts

@@ -1,227 +0,0 @@
-import type { AuthAdapter, AuthUser } from '@fayz-ai/core'
-import {
-  createAuthRuntime,
-  createMockAuthAdapter,
-  type AuthPluginOptions,
-} from '@fayz-ai/plugin-auth'
-import { getShopProvider } from '@fayz-ai/shop/runtime'
-import { setShopAccessTokenResolver } from '@fayz-ai/sdk/shop'
-import { useSessionStore } from './stores/session.store'
-
-// ---------------------------------------------------------------------------
-// Customer auth — the SAME AuthAdapter contract createSaasApp uses, so the
-// mock and Supabase adapters from @fayz-ai/auth serve both the saas admin and
-// the storefront customer. The storefront adds one layer on top: linking the
-// auth identity to a ShopCustomer record (find-or-create by email) so orders
-// and purchase history attach to a customer.
-// ---------------------------------------------------------------------------
-
-export type StorefrontAuthAdapter = AuthAdapter | 'mock' | 'supabase' | (string & {})
-
-export interface StorefrontAuthConfig {
-  adapter?: AuthPluginOptions['adapter']
-  provider?: AuthPluginOptions['provider']
-  routes?: AuthPluginOptions['routes']
-  supabase?: AuthPluginOptions['supabase']
-}
-
-let _adapter: AuthAdapter | null = null
-
-function isAuthAdapter(value: unknown): value is AuthAdapter {
-  return Boolean(
-    value &&
-      typeof value === 'object' &&
-      'getSession' in value &&
-      'signIn' in value &&
-      'signOut' in value,
-  )
-}
-
-function normalizeAuthConfig(
-  configured: StorefrontAuthAdapter | StorefrontAuthConfig | undefined,
-): StorefrontAuthConfig {
-  if (!configured) return {}
-  if (typeof configured === 'string' || isAuthAdapter(configured)) return { adapter: configured }
-  return configured
-}
-
-export function resolveAuthAdapter(
-  configured: StorefrontAuthAdapter | StorefrontAuthConfig | undefined,
-  fallback?: { supabaseUrl?: string; supabaseAnonKey?: string },
-): AuthAdapter {
-  const config = normalizeAuthConfig(configured)
-  return createAuthRuntime({
-    provider: config.provider ?? config.adapter ?? (fallback?.supabaseUrl ? 'supabase' : 'mock'),
-    adapter: config.adapter,
-    routes: config.routes,
-    requireAuth: false,
-    supabase: {
-      url: config.supabase?.url ?? fallback?.supabaseUrl,
-      anonKey: config.supabase?.anonKey ?? fallback?.supabaseAnonKey,
-      client: config.supabase?.client,
-      callbackUrl: config.supabase?.callbackUrl,
-      resetPasswordUrl: config.supabase?.resetPasswordUrl,
-    },
-  }).adapter
-}
-
-// The shopper's current access token, handed to the shop REST client so its
-// requests reach PostgREST as the signed-in user instead of as `anon`. Held
-// here rather than in the session store because it is a credential: it must not
-// be persisted to localStorage alongside the customer id. The Supabase client
-// owns its own refresh; this is only a mirror of the live value.
-let _accessToken: string | null = null
-
-/** Whether an authenticated identity was ever seen this session. Distinguishes
- *  "signed out" from "was never signed in" — see the onAuthStateChange guard. */
-let _hadAuthUser = false
-
-/** Refresh the mirrored token from the adapter. Safe to call on any event. */
-async function syncAccessToken(adapter: AuthAdapter): Promise<void> {
-  try {
-    const existing = await adapter.getSession()
-    _accessToken = existing?.session.accessToken ?? null
-  } catch {
-    _accessToken = null
-  }
-}
-
-/** Called once by createStorefrontApp. Restores any persisted session. */
-export function initCustomerAuth(adapter: AuthAdapter): void {
-  _adapter = adapter
-
-  // Registered before the first await so no request can slip out anonymously
-  // while the session is still being restored.
-  setShopAccessTokenResolver(() => _accessToken)
-
-  adapter
-    .getSession()
-    .then((existing) => {
-      _accessToken = existing?.session.accessToken ?? null
-      if (!existing) return
-      _hadAuthUser = true
-      const store = useSessionStore.getState()
-      // Re-link only when the persisted shop session doesn't match the auth user
-      if (store.email !== existing.user.email) {
-        void linkCustomer(existing.user)
-      }
-    })
-    .catch(() => {})
-
-  adapter.onAuthStateChange((user) => {
-    if (!user) {
-      _accessToken = null
-      // Only tear down the shop session if there WAS an authenticated identity
-      // to lose. The Supabase adapter fires this once on boot with a null user
-      // (INITIAL_SESSION), and clearing unconditionally wiped the guest's local
-      // session on every page load — a guest who checked out could no longer
-      // find their order after a reload. The mock adapter never surfaced this
-      // because it always restored a session.
-      if (_hadAuthUser) {
-        _hadAuthUser = false
-        useSessionStore.getState().signOut()
-      }
-      return
-    }
-    _hadAuthUser = true
-    // Covers token refresh too, not just sign-in: the callback carries the user
-    // but not the token, and a stale token would 401 every read an hour in.
-    void syncAccessToken(adapter)
-  })
-}
-
-export function getCustomerAuthAdapter(): AuthAdapter {
-  if (!_adapter) _adapter = createMockAuthAdapter()
-  return _adapter
-}
-
-/** Resolve (find-or-create + server-side auth link) the ShopCustomer for an email. */
-async function resolveShopCustomer(email: string, name: string) {
-  const provider = getShopProvider()
-  // Preferred: provider.resolveCustomer find-or-creates AND links auth.uid
-  // server-side (RLS-safe). Falls back to generic CRUD for legacy providers.
-  if (provider.resolveCustomer) return provider.resolveCustomer({ email, name })
-  const matches = await provider.listCustomers({ search: email, limit: 10 })
-  const existing = matches.find((c) => (c.email ?? '').toLowerCase() === email)
-  if (existing) return existing
-  const parts = name.trim().split(/\s+/).filter(Boolean)
-  return provider.createCustomer({
-    firstName: parts[0] ?? email.split('@')[0] ?? 'Cliente',
-    lastName: parts.slice(1).join(' '),
-    email,
-  })
-}
-
-/** Find-or-create the ShopCustomer for an auth identity and persist the session. */
-async function linkCustomer(user: AuthUser, fullName?: string): Promise<{ customerId: string }> {
-  const email = (user.email ?? '').trim().toLowerCase()
-  const name = fullName ?? user.fullName ?? ''
-  const customer = await resolveShopCustomer(email, name)
-  useSessionStore.getState().setSession({
-    customerId: customer.id,
-    email,
-    name: name || `${customer.firstName} ${customer.lastName}`.trim(),
-  })
-  return { customerId: customer.id }
-}
-
-export interface EstablishSessionOptions {
-  /** Provided → adapter.signIn; omitted → passwordless customer identity via signUp (mock-friendly). */
-  password?: string
-  name?: string
-}
-
-/**
- * Sign a customer in through the auth adapter and link the ShopCustomer.
- * Used by the account page sign-in AND by checkout (so a buyer is signed in
- * for "my purchases" immediately after purchase) — one auth path, two doors.
- */
-export async function establishCustomerSession(
-  email: string,
-  opts?: EstablishSessionOptions,
-): Promise<{ customerId: string }> {
-  const normalized = email.trim().toLowerCase()
-  if (opts?.password) {
-    const adapter = getCustomerAuthAdapter()
-    const session = await adapter.signIn(normalized, opts.password)
-    // Before linkCustomer, not after: linkCustomer calls shop_resolve_customer,
-    // which reads auth.uid() to fill auth_user_id. Sent with the old token that
-    // link silently no-ops and the account stays unlinked forever.
-    _accessToken = session.accessToken ?? null
-    _hadAuthUser = true
-    return linkCustomer(session.user.email ? session.user : { ...session.user, email: normalized }, opts.name)
-  }
-  // Guest / passwordless checkout: do NOT create an auth account (that made
-  // returning guests fail with "user already registered" on Supabase). Just
-  // resolve the ShopCustomer and persist the local session for order history.
-  return linkCustomer({ id: '', email: normalized } as AuthUser, opts?.name)
-}
-
-/** Convenience wrapper — passwordless email sign-in (guest checkout path). */
-export function signInByEmail(email: string, name?: string): Promise<{ customerId: string }> {
-  return establishCustomerSession(email, { name })
-}
-
-/** Explicit account creation (account page "Criar conta" form). */
-export async function signUpCustomer(
-  email: string,
-  password: string,
-  name: string,
-): Promise<{ customerId: string }> {
-  const adapter = getCustomerAuthAdapter()
-  const normalized = email.trim().toLowerCase()
-  const session = await adapter.signUp(normalized, password, name)
-  _accessToken = session.accessToken ?? null
-  _hadAuthUser = true
-  return linkCustomer(session.user.email ? session.user : { ...session.user, email: normalized }, name)
-}
-
-export async function signOutCustomer(): Promise<void> {
-  try {
-    await getCustomerAuthAdapter().signOut()
-  } finally {
-    _accessToken = null
-    _hadAuthUser = false
-    useSessionStore.getState().signOut()
-  }
-}

package/src/blocks.tsx

@@ -1,51 +0,0 @@
-import { registerBlock } from '@fayz-ai/core'
-import type { BlockNode } from '@fayz-ai/core'
-import type { StorefrontSection } from './sections'
-import { HeroSection } from './components/sections/HeroSection'
-import { CategoryShowcase } from './components/sections/CategoryShowcase'
-import { ProductRail } from './components/sections/ProductRail'
-import { MediaCarousel } from './components/sections/MediaCarousel'
-import { ProductSlider } from './components/sections/ProductSlider'
-import {
-  BenefitsRow,
-  PromoBanner,
-  ManifestoBlock,
-  Testimonials,
-  NewsletterBand,
-} from './components/sections/MiscSections'
-
-// ---------------------------------------------------------------------------
-// Storefront blocks — the section components registered into the universal
-// block registry. This replaces HomePage's hardcoded switch: a home page is now
-// a block tree (`{ type, props }[]`) resolved through the registry, identical
-// to how admin pages will compose. Section prop shapes are unchanged, so the
-// components are registered directly.
-// ---------------------------------------------------------------------------
-
-let registered = false
-
-export function registerStorefrontBlocks(): void {
-  if (registered) return
-  registered = true
-  registerBlock('hero', HeroSection, { source: 'sdk', label: 'Hero' })
-  registerBlock('mediaCarousel', MediaCarousel, { source: 'sdk', label: 'Media carousel' })
-  registerBlock('categories', CategoryShowcase, { source: 'sdk', label: 'Categories' })
-  registerBlock('products', ProductRail, { source: 'sdk', label: 'Product rail' })
-  registerBlock('productSlider', ProductSlider, { source: 'sdk', label: 'Product slider' })
-  registerBlock('benefits', BenefitsRow, { source: 'sdk', label: 'Benefits row' })
-  registerBlock('banner', PromoBanner, { source: 'sdk', label: 'Promo banner' })
-  registerBlock('manifesto', ManifestoBlock, { source: 'sdk', label: 'Manifesto' })
-  registerBlock('testimonials', Testimonials, { source: 'sdk', label: 'Testimonials' })
-  registerBlock('newsletter', NewsletterBand, { source: 'sdk', label: 'Newsletter band' })
-}
-
-// Registration happens in initStorefrontRuntime (both the scaffold and
-// createStorefront call it) so importing this module stays side-effect-free.
-
-/** Convert the typed storefront section blueprint into a generic block tree. */
-export function sectionsToBlocks(sections: readonly StorefrontSection[]): BlockNode[] {
-  return sections.map((section, i) => {
-    const { type, ...props } = section
-    return { type, id: `${type}-${i}`, props: props as Record<string, unknown> }
-  })
-}

package/src/catalog.ts

@@ -1,3 +0,0 @@
-// Front-door re-export of @fayz-ai/shop/catalog (mock catalog builders/data)
-// so storefront apps import from `@fayz-ai/storefront/catalog`.
-export * from '@fayz-ai/shop/catalog'

package/src/component-contracts.ts

@@ -1,154 +0,0 @@
-import type React from 'react'
-import type { Category, CreateProductEnquiryInput, Product, ProductEnquiry, ProductImage } from '@fayz-ai/shop/types'
-import type { ProductOptionGroup, ProductOptionSelection } from './product-options'
-import type { ResolvedStorefrontConfig, StorefrontCommerceMode } from './config'
-import type { MediaCarouselItem } from './sections'
-import type { CartState } from './stores/cart.store'
-
-export interface StorefrontComponentBaseProps {
-  config: ResolvedStorefrontConfig
-  commerceMode: StorefrontCommerceMode
-  className?: string
-  testId?: string
-}
-
-export interface StorefrontActions {
-  navigateTo: (to: string) => void
-  addToCart: (product: Product, quantity?: number, options?: ProductOptionSelection) => void
-  openCart: () => void
-  closeCart: () => void
-  createProductEnquiry: (input: CreateProductEnquiryInput) => Promise<ProductEnquiry>
-}
-
-export interface ProductCardProps extends StorefrontComponentBaseProps {
-  product: Product
-  actions: Pick<StorefrontActions, 'navigateTo' | 'addToCart' | 'openCart'>
-}
-
-export interface ProductDetailProps extends StorefrontComponentBaseProps {
-  product: Product
-  primaryImage?: ProductImage
-  optionGroups: ProductOptionGroup[]
-  selectedOptions: ProductOptionSelection
-  setSelectedOptions: React.Dispatch<React.SetStateAction<ProductOptionSelection>>
-  quantity: number
-  setQuantity: React.Dispatch<React.SetStateAction<number>>
-  soldOut: boolean
-  lowStock: boolean
-  actions: Pick<StorefrontActions, 'addToCart' | 'createProductEnquiry' | 'navigateTo'>
-  addToCart: () => void
-  openEnquiry: () => void
-}
-
-export interface ProductGalleryProps extends StorefrontComponentBaseProps {
-  product: Product
-  images: ProductImage[]
-  primaryImage?: ProductImage
-}
-
-export interface ProductPriceProps extends StorefrontComponentBaseProps {
-  product: Product
-  value: number
-  compareAt?: number | null
-}
-
-export interface ProductActionsProps extends StorefrontComponentBaseProps {
-  product: Product
-  quantity: number
-  setQuantity: React.Dispatch<React.SetStateAction<number>>
-  soldOut: boolean
-  actions: Pick<StorefrontActions, 'addToCart' | 'createProductEnquiry' | 'navigateTo'>
-  addToCart: () => void
-  openEnquiry: () => void
-}
-
-export interface ProductEnquiryFormContractProps extends StorefrontComponentBaseProps {
-  product: Product
-  onSuccess?: () => void
-}
-
-export interface CategoryCardProps extends StorefrontComponentBaseProps {
-  category: Category
-  actions: Pick<StorefrontActions, 'navigateTo'>
-}
-
-export interface CollectionSectionProps extends StorefrontComponentBaseProps {
-  title: string
-  subtitle?: string
-  products: Product[]
-  category?: Category
-  children?: React.ReactNode
-}
-
-export interface HeroSectionContractProps extends StorefrontComponentBaseProps {
-  title: string
-  subtitle?: string
-  eyebrow?: string
-  image?: string
-  cta?: string
-  href?: string
-  children?: React.ReactNode
-}
-
-export interface MediaCarouselProps extends StorefrontComponentBaseProps {
-  items: MediaCarouselItem[]
-  height?: 'medium' | 'tall' | 'screen'
-  autoplayMs?: number
-  overlay?: 'dark' | 'soft' | 'none'
-}
-
-export interface ProductSliderProps extends StorefrontComponentBaseProps {
-  title: string
-  subtitle?: string
-  eyebrow?: string
-  filter?: 'sale' | 'new' | 'all'
-  categoryName?: string
-  collection?: string
-  limit?: number
-  cta?: string
-  href?: string
-}
-
-export interface StorefrontChromeProps extends StorefrontComponentBaseProps {
-  children?: React.ReactNode
-}
-
-export interface StorefrontStateProps extends StorefrontComponentBaseProps {
-  title?: string
-  message?: string
-  children?: React.ReactNode
-}
-
-/**
- * Extra content rendered inside CartDrawer's footer, right after the
- * "Finalizar compra" button — e.g. an alternative checkout path like
- * "Finalizar via WhatsApp". Unlike every other entry in
- * StorefrontComponents, this isn't a whole-component replacement:
- * CartDrawer is always the SDK's own, this only adds optional content
- * inside it. Only rendered when the cart has lines (same condition as the
- * checkout button itself).
- */
-export interface CartDrawerFooterExtraProps extends StorefrontComponentBaseProps {
-  cart: CartState
-}
-
-export interface StorefrontComponents {
-  ProductCard?: React.ComponentType<ProductCardProps>
-  ProductDetail?: React.ComponentType<ProductDetailProps>
-  ProductGallery?: React.ComponentType<ProductGalleryProps>
-  ProductPrice?: React.ComponentType<ProductPriceProps>
-  ProductActions?: React.ComponentType<ProductActionsProps>
-  ProductEnquiryForm?: React.ComponentType<ProductEnquiryFormContractProps>
-  CategoryCard?: React.ComponentType<CategoryCardProps>
-  CollectionSection?: React.ComponentType<CollectionSectionProps>
-  HeroSection?: React.ComponentType<HeroSectionContractProps>
-  MediaCarousel?: React.ComponentType<MediaCarouselProps>
-  ProductSlider?: React.ComponentType<ProductSliderProps>
-  Header?: React.ComponentType<StorefrontChromeProps>
-  Footer?: React.ComponentType<StorefrontChromeProps>
-  Shell?: React.ComponentType<StorefrontChromeProps>
-  EmptyState?: React.ComponentType<StorefrontStateProps>
-  LoadingState?: React.ComponentType<StorefrontStateProps>
-  ErrorState?: React.ComponentType<StorefrontStateProps>
-  CartDrawerFooterExtra?: React.ComponentType<CartDrawerFooterExtraProps>
-}

package/src/component-selectors.ts

@@ -1,31 +0,0 @@
-import { TID } from './testids'
-
-/**
- * Stable selectors that custom storefront components must preserve.
- *
- * Apps can fully customize the visual tree, but replacement components still
- * need these anchors so smoke tests, QA, and agents can operate stores.
- */
-export const productCardComponentContract = {
-  root: { 'data-testid': TID.productCard },
-  name: { 'data-testid': TID.productCardName },
-  priceTestId: TID.productCardPrice,
-  addButton: { 'data-testid': TID.productCardAdd },
-} as const
-
-export const storefrontComponentContracts = {
-  productCard: productCardComponentContract,
-  productDetail: {
-    root: { 'data-testid': TID.pdpRoot },
-    gallery: { 'data-testid': TID.pdpGallery },
-    name: { 'data-testid': TID.pdpName },
-    description: { 'data-testid': TID.pdpDescription },
-    actions: { 'data-testid': TID.pdpActions },
-    addButton: { 'data-testid': TID.pdpAddToCart },
-    enquiryButton: { 'data-testid': TID.pdpEnquiryButton },
-    enquiryForm: { 'data-testid': TID.enquiryForm },
-  },
-} as const
-
-export type ProductCardComponentContract = typeof productCardComponentContract
-export type ProductDetailComponentContract = typeof storefrontComponentContracts.productDetail