@fayz-ai/plugin-shop 0.9.0 → 0.10.0

package/src/components/ShopSettings.tsx

@@ -1,108 +0,0 @@
-import React from 'react'
-import { SettingsGroup, ToggleRow, SelectRow } from '@fayz-ai/saas'
-
-export interface ShopSettingsProps {
-  currency?: { code?: string; locale?: string; symbol?: string }
-}
-
-const CURRENCIES = [
-  { value: 'BRL', label: 'Real (R$)' },
-  { value: 'USD', label: 'US Dollar ($)' },
-  { value: 'EUR', label: 'Euro (€)' },
-  { value: 'GBP', label: 'British Pound (£)' },
-]
-
-const LOCALES = [
-  { value: 'pt-BR', label: 'Português (Brasil)' },
-  { value: 'en-US', label: 'English (US)' },
-  { value: 'es-ES', label: 'Español' },
-]
-
-/**
- * Shop plugin settings — store, catalog, checkout and notification config.
- * Seeded from the plugin's currency option; interactive (local state). Wire to
- * persisted plugin prefs when the shop settings store lands.
- */
-export function ShopSettings({ currency }: ShopSettingsProps) {
-  const [code, setCode] = React.useState(currency?.code ?? 'BRL')
-  const [locale, setLocale] = React.useState(currency?.locale ?? 'pt-BR')
-  const [showOutOfStock, setShowOutOfStock] = React.useState(true)
-  const [trackInventory, setTrackInventory] = React.useState(true)
-  const [requireSku, setRequireSku] = React.useState(false)
-  const [guestCheckout, setGuestCheckout] = React.useState(true)
-  const [enableDiscounts, setEnableDiscounts] = React.useState(true)
-  const [orderEmails, setOrderEmails] = React.useState(true)
-  const [lowStockAlerts, setLowStockAlerts] = React.useState(false)
-
-  return (
-    <div className="space-y-4">
-      <SettingsGroup title="Loja" description="Moeda e formatação da vitrine.">
-        <SelectRow
-          label="Moeda"
-          description="Moeda padrão para preços e checkout."
-          value={code}
-          options={CURRENCIES}
-          onChange={setCode}
-        />
-        <SelectRow
-          label="Idioma / formato"
-          description="Formatação de números, preços e datas."
-          value={locale}
-          options={LOCALES}
-          onChange={setLocale}
-        />
-      </SettingsGroup>
-
-      <SettingsGroup title="Catálogo" description="Como os produtos aparecem e são gerenciados.">
-        <ToggleRow
-          label="Mostrar produtos esgotados"
-          description="Exibir itens sem estoque na vitrine."
-          checked={showOutOfStock}
-          onChange={setShowOutOfStock}
-        />
-        <ToggleRow
-          label="Controlar estoque"
-          description="Acompanhar quantidade e dar baixa no checkout."
-          checked={trackInventory}
-          onChange={setTrackInventory}
-        />
-        <ToggleRow
-          label="Exigir SKU"
-          description="Tornar o SKU obrigatório ao criar produtos."
-          checked={requireSku}
-          onChange={setRequireSku}
-        />
-      </SettingsGroup>
-
-      <SettingsGroup title="Checkout" description="Opções de compra e pagamento.">
-        <ToggleRow
-          label="Checkout sem cadastro"
-          description="Permitir compra como convidado."
-          checked={guestCheckout}
-          onChange={setGuestCheckout}
-        />
-        <ToggleRow
-          label="Cupons de desconto"
-          description="Habilitar códigos de desconto no carrinho."
-          checked={enableDiscounts}
-          onChange={setEnableDiscounts}
-        />
-      </SettingsGroup>
-
-      <SettingsGroup title="Notificações" description="Avisos por e-mail da loja.">
-        <ToggleRow
-          label="E-mail de novo pedido"
-          description="Notificar a equipe a cada novo pedido."
-          checked={orderEmails}
-          onChange={setOrderEmails}
-        />
-        <ToggleRow
-          label="Alerta de estoque baixo"
-          description="Avisar quando produtos atingirem o mínimo."
-          checked={lowStockAlerts}
-          onChange={setLowStockAlerts}
-        />
-      </SettingsGroup>
-    </div>
-  )
-}

package/src/data/customerDataProvider.ts

@@ -1,31 +0,0 @@
-import type { CrudQuery, CrudResult, DataProvider } from '@fayz-ai/core'
-import type { CreateCustomerInput, ShopCustomer, UpdateCustomerInput } from '@fayz-ai/shop'
-import { applyQuery, resolve, type ShopProviderResolver } from './shared'
-
-export function createShopCustomerDataProvider(
-  provider: ShopProviderResolver,
-): DataProvider<ShopCustomer> {
-  return {
-    async list(query: CrudQuery): Promise<CrudResult<ShopCustomer>> {
-      const rows = await resolve(provider).listCustomers(
-        query.search ? { search: query.search } : undefined,
-      )
-      return applyQuery(rows, query)
-    },
-
-    async create(data): Promise<ShopCustomer> {
-      return resolve(provider).createCustomer(data as unknown as CreateCustomerInput)
-    },
-
-    async update(id: string, data: Partial<ShopCustomer>): Promise<ShopCustomer> {
-      // ordersCount / totalSpent are trigger-maintained (shop_refresh_customer_stats);
-      // never send them back or a stale form value would fight the database.
-      const { ordersCount: _o, totalSpent: _t, ...patch } = data
-      return resolve(provider).updateCustomer(id, patch as UpdateCustomerInput)
-    },
-
-    async remove(id: string): Promise<void> {
-      await resolve(provider).deleteCustomer(id)
-    },
-  }
-}

package/src/data/discountDataProvider.ts

@@ -1,42 +0,0 @@
-import type { CrudQuery, CrudResult, DataProvider } from '@fayz-ai/core'
-import type { CreateDiscountInput, Discount, UpdateDiscountInput } from '@fayz-ai/shop'
-import { applyQuery, resolve, type ShopProviderResolver } from './shared'
-
-export function createShopDiscountDataProvider(
-  provider: ShopProviderResolver,
-): DataProvider<Discount> {
-  return {
-    async list(query: CrudQuery): Promise<CrudResult<Discount>> {
-      const rows = await resolve(provider).listDiscounts()
-      const term = query.search?.trim().toLowerCase()
-      const filtered = term
-        ? rows.filter((d) =>
-            d.title.toLowerCase().includes(term) || (d.code ?? '').toLowerCase().includes(term))
-        : rows
-      return applyQuery(filtered, query, 'status')
-    },
-
-    async create(data): Promise<Discount> {
-      const input = data as unknown as Partial<Discount>
-      return resolve(provider).createDiscount({
-        ...(input as CreateDiscountInput),
-        // Codes are matched case-insensitively server-side; store them upper so
-        // the admin list reads consistently.
-        code: input.code ? String(input.code).trim().toUpperCase() : undefined,
-      } as CreateDiscountInput)
-    },
-
-    async update(id: string, data: Partial<Discount>): Promise<Discount> {
-      // timesUsed is incremented by shop_place_order inside the order transaction.
-      const { timesUsed: _used, ...patch } = data
-      if (patch.code !== undefined) {
-        patch.code = patch.code ? String(patch.code).trim().toUpperCase() : null
-      }
-      return resolve(provider).updateDiscount(id, patch as UpdateDiscountInput)
-    },
-
-    async remove(id: string): Promise<void> {
-      await resolve(provider).deleteDiscount(id)
-    },
-  }
-}

package/src/data/productDataProvider.ts

@@ -1,54 +0,0 @@
-import type { CrudQuery, CrudResult, DataProvider } from '@fayz-ai/core'
-import type { CreateProductInput, Product, UpdateProductInput } from '@fayz-ai/shop'
-import { slugify } from '../views/productEntity'
-import { applyQuery, resolve, type ShopProviderResolver } from './shared'
-
-export type { ShopProviderResolver }
-
-// ---------------------------------------------------------------------------
-// Bridges the generic CRUD scaffolding (DataProvider) to the shop provider, so
-// the product screens are the same createCrudPage machinery every other module
-// uses instead of a bespoke form.
-//
-// Which shop provider is injected decides whether writes work at all:
-//   • createSupabaseShopProvider — authenticates as the merchant (their JWT),
-//     full CRUD, subject to the tenant-member RLS policies.
-//   • createFayzShopProvider — the storefront's anonymous REST client. Reads
-//     work; every write throws FayzShopError 501 by design. The form surfaces
-//     that message rather than pretending the save succeeded.
-// ---------------------------------------------------------------------------
-
-export function createShopProductDataProvider(provider: ShopProviderResolver): DataProvider<Product> {
-  return {
-    async list(query: CrudQuery): Promise<CrudResult<Product>> {
-      const rows = await resolve(provider).listProducts(
-        query.search ? { search: query.search } : undefined,
-      )
-      return applyQuery(rows, query, 'status')
-    },
-
-    async create(data): Promise<Product> {
-      const input = data as unknown as Partial<Product>
-      // The storefront URL is required by the table's UNIQUE(tenant_id, slug);
-      // deriving it from the name keeps the merchant from having to know that.
-      const slug = input.slug?.trim() || slugify(String(input.name ?? ''))
-      return resolve(provider).createProduct({
-        ...(input as CreateProductInput),
-        slug,
-      } as CreateProductInput)
-    },
-
-    async update(id: string, data: Partial<Product>): Promise<Product> {
-      const patch = { ...data }
-      if (patch.slug !== undefined && !String(patch.slug).trim()) {
-        // Cleared on purpose → regenerate rather than write an empty slug.
-        patch.slug = slugify(String(patch.name ?? ''))
-      }
-      return resolve(provider).updateProduct(id, patch as UpdateProductInput)
-    },
-
-    async remove(id: string): Promise<void> {
-      await resolve(provider).deleteProduct(id)
-    },
-  }
-}

package/src/data/shared.ts

@@ -1,42 +0,0 @@
-import type { CrudQuery, CrudResult } from '@fayz-ai/core'
-import type { ShopProvider } from '@fayz-ai/shop'
-
-export type ShopProviderResolver = ShopProvider | (() => ShopProvider)
-
-export const resolve = (p: ShopProviderResolver): ShopProvider => (typeof p === 'function' ? p() : p)
-
-/**
- * Paging, sorting and facet filtering applied client-side: the shop provider's
- * list methods take a search term but no offset, sort or filter parameters.
- * Fine at storefront catalogue sizes; revisit if a tenant grows past a few
- * thousand rows, where it should move into the query.
- */
-export function applyQuery<T>(
-  rows: T[],
-  query: CrudQuery,
-  facetKey?: keyof T & string,
-): CrudResult<T> {
-  const prop = (row: T, key: string): unknown => (row as Record<string, unknown>)[key]
-  let data = rows
-
-  if (facetKey) {
-    const wanted = query.filters?.[facetKey]
-    if (wanted && wanted !== 'all') data = data.filter((row) => prop(row, facetKey) === wanted)
-  }
-
-  if (query.sortBy) {
-    const dir = query.sortDir === 'desc' ? -1 : 1
-    const key = query.sortBy
-    data = [...data].sort((a, b) => {
-      const av = prop(a, key)
-      const bv = prop(b, key)
-      if (typeof av === 'number' && typeof bv === 'number') return (av - bv) * dir
-      return String(av ?? '').localeCompare(String(bv ?? ''), 'pt-BR') * dir
-    })
-  }
-
-  const total = data.length
-  const page = query.page ?? 1
-  const size = query.pageSize ?? total
-  return { data: data.slice((page - 1) * size, page * size), total }
-}

package/src/data/shippingZoneDataProvider.ts

@@ -1,49 +0,0 @@
-import type { CrudQuery, CrudResult, DataProvider } from '@fayz-ai/core'
-import type { CreateShippingZoneInput, ShippingZone, UpdateShippingZoneInput } from '@fayz-ai/shop'
-import { applyQuery, resolve, type ShopProviderResolver } from './shared'
-
-/**
- * Delivery zones CRUD.
- *
- * The form takes CEPs however the merchant types them ('22.041-001', '22041001')
- * and the provider normalises to the 8 bare digits shipping_zones compares on —
- * asking a shop owner to strip punctuation is how a range silently stops
- * matching and a whole city stops being served.
- */
-export function createShopShippingZoneDataProvider(
-  provider: ShopProviderResolver,
-): DataProvider<ShippingZone> {
-  const shop = () => {
-    const p = resolve(provider)
-    if (!p.listShippingZones) {
-      throw new Error('Este provider de loja não suporta zonas de entrega.')
-    }
-    return p
-  }
-
-  return {
-    async list(query: CrudQuery): Promise<CrudResult<ShippingZone>> {
-      const rows = await shop().listShippingZones!()
-      const term = query.search?.trim().toLowerCase()
-      const filtered = term
-        ? rows.filter((z) =>
-            z.name.toLowerCase().includes(term) || (z.carrier ?? '').toLowerCase().includes(term))
-        : rows
-      return applyQuery(filtered, query)
-    },
-
-    async create(data): Promise<ShippingZone> {
-      return shop().createShippingZone!(data as unknown as CreateShippingZoneInput)
-    },
-
-    async update(id: string, data: Partial<ShippingZone>): Promise<ShippingZone> {
-      // tenantId is set from the session on the server side; never from the form.
-      const { id: _id, tenantId: _tenant, ...patch } = data
-      return shop().updateShippingZone!(id, patch as UpdateShippingZoneInput)
-    },
-
-    async remove(id: string): Promise<void> {
-      await shop().deleteShippingZone!(id)
-    },
-  }
-}

package/src/index.ts

@@ -1,270 +0,0 @@
-import React from 'react'
-import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
-import { setShopTenantResolver, getShopProvider } from '@fayz-ai/shop'
-import { useOrganizationStore, createCrudPage, registerEntityPath } from '@fayz-ai/saas'
-import { buildShopProductEntity } from './views/productEntity'
-import { buildShopCustomerEntity } from './views/customerEntity'
-import { buildShopDiscountEntity } from './views/discountEntity'
-import { buildShopShippingZoneEntity } from './views/shippingZoneEntity'
-import { createShopProductDataProvider } from './data/productDataProvider'
-import { createShopCustomerDataProvider } from './data/customerDataProvider'
-import { createShopDiscountDataProvider } from './data/discountDataProvider'
-import { createShopShippingZoneDataProvider } from './data/shippingZoneDataProvider'
-import type { ShopProviderResolver } from './ShopPage'
-import { ShopSettings } from './components/ShopSettings'
-import { ChannelsPage } from './views/ChannelsPage'
-
-const ShopPage = React.lazy(() => import('./ShopPage').then((m) => ({ default: m.ShopPage })))
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface ShopPluginOptions {
-  navPosition?: number
-  navSection?: 'main' | 'secondary' | 'settings'
-  navLabel?: string
-  /** Override the accordion child labels (Produtos / Pedidos / Clientes / Descontos). */
-  sectionLabels?: Partial<Record<'products' | 'orders' | 'customers' | 'discounts' | 'shipping', string>>
-  scope?: PluginScope
-  verticalId?: VerticalId
-  currency?: { code?: string; locale?: string; symbol?: string }
-  provider?: ShopProviderResolver
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createShopPlugin(options?: ShopPluginOptions): PluginManifest {
-  const curr = { code: 'BRL', locale: 'pt-BR', symbol: 'R$', ...options?.currency }
-
-  // Scope fallback shop queries to the active organization. Apps can inject a
-  // provider when they want SDK-owned data access instead of the global runtime.
-  setShopTenantResolver(() => useOrganizationStore.getState().currentOrg?.id)
-
-  // Teach the shared person-path registry where a SHOP customer lives. The
-  // built-in map ships veterinary defaults (customer → /registry/tutors), so
-  // without this PersonLink would resolve a shop customer to the wrong module.
-  // Clientes now lives at the top level (/customers), out of the Loja accordion.
-  registerEntityPath('shop_customer', '/customers')
-
-  type ShopSection = 'products' | 'orders' | 'customers' | 'discounts' | 'shipping'
-
-  // One component per section so each gets its own route. The shell nests any
-  // entry whose route is a sub-path of another (same rule the courses modules
-  // use), so /shop/products … /shop/discounts render as an accordion under
-  // "Loja" instead of one link with everything hidden behind tabs.
-  const pageFor = (section?: ShopSection): React.ComponentType<unknown> => {
-    const Wrapped: React.ComponentType<unknown> = () =>
-      React.createElement(React.Suspense, { fallback: null },
-        React.createElement(
-          ShopPage as React.ComponentType<{ provider?: ShopProviderResolver; section?: ShopSection }>,
-          { provider: options?.provider, section },
-        )
-      )
-    Wrapped.displayName = section ? `ShopPage:${section}` : 'ShopPageWrapper'
-    return Wrapped
-  }
-
-  // Products, customers and discounts all get the full generic CRUD (list +
-  // form + detail + delete) from their EntityDef, rather than three bespoke
-  // read-only tables. Orders stay on the custom page: an order is not a CRUD
-  // record — it needs fulfilment, refunds and a line-item view, which is its
-  // own screen.
-  const resolveProvider = () =>
-    typeof options?.provider === 'function'
-      ? options.provider()
-      : options?.provider ?? getShopProvider()
-
-  const ProductsCrudPage = createCrudPage(buildShopProductEntity(curr.code, resolveProvider), {
-    dataProvider: createShopProductDataProvider(resolveProvider),
-    feature: 'shop',
-  })
-
-  const CustomersCrudPage = createCrudPage(buildShopCustomerEntity(), {
-    dataProvider: createShopCustomerDataProvider(resolveProvider),
-    feature: 'shop',
-  })
-
-  const DiscountsCrudPage = createCrudPage(buildShopDiscountEntity(), {
-    dataProvider: createShopDiscountDataProvider(resolveProvider),
-    feature: 'shop',
-  })
-
-  const ShippingZonesCrudPage = createCrudPage(buildShopShippingZoneEntity(curr.code), {
-    dataProvider: createShopShippingZoneDataProvider(resolveProvider),
-    feature: 'shop',
-  })
-
-  const CRUD_PAGES: Partial<Record<ShopSection, React.ComponentType<unknown>>> = {
-    products: ProductsCrudPage as React.ComponentType<unknown>,
-    customers: CustomersCrudPage as React.ComponentType<unknown>,
-    discounts: DiscountsCrudPage as React.ComponentType<unknown>,
-    shipping: ShippingZonesCrudPage as React.ComponentType<unknown>,
-  }
-
-  // "Clientes" is intentionally NOT here: it moved out of the Loja accordion to
-  // a top-level nav item (/customers), registered separately below. The shell
-  // nests by route prefix, so a route under /shop is what put it inside "Loja".
-  const SECTIONS: Array<{ id: ShopSection; label: string; icon: string }> = [
-    { id: 'products',  label: options?.sectionLabels?.products  ?? 'Produtos',  icon: 'Package' },
-    { id: 'orders',    label: options?.sectionLabels?.orders    ?? 'Pedidos',   icon: 'ShoppingCart' },
-    { id: 'discounts', label: options?.sectionLabels?.discounts ?? 'Descontos', icon: 'Tag' },
-    { id: 'shipping',  label: options?.sectionLabels?.shipping  ?? 'Entrega',   icon: 'Truck' },
-  ]
-
-  // Standalone Customers page — same CRUD component, now at /customers so it
-  // reads as its own top-level destination instead of a Loja sub-tab.
-  const CustomersNavLabel = options?.sectionLabels?.customers ?? 'Clientes'
-
-  // Canais de venda — wraps the ChannelsPage with the app's shop provider.
-  const ChannelsPageWrapped: React.ComponentType<unknown> = () =>
-    React.createElement(ChannelsPage, { resolveProvider: options?.provider })
-  ChannelsPageWrapped.displayName = 'ChannelsPage'
-
-  const navSection = options?.navSection ?? 'main'
-  const navPosition = options?.navPosition ?? 6
-
-  return {
-    id: 'shop',
-    name: options?.navLabel ?? 'Shop',
-    icon: 'ShoppingBag',
-    version: '1.0.0',
-    scope: options?.scope ?? 'vertical',
-    verticalId: options?.verticalId,
-    // Storefront/commerce-operator-console surface — targets the ecommerce
-    // Panel world, not a saas admin app.
-    scaffolds: ['ecommerce'],
-    defaultEnabled: true,
-    dependencies: [],
-    navigation: [
-      {
-        section: navSection,
-        position: navPosition,
-        label: options?.navLabel ?? 'Shop',
-        route: '/shop',
-        icon: 'ShoppingBag',
-        permission: { feature: 'shop', action: 'read' as const },
-        // "Loja" and "Produtos" are the same screen — don't list both.
-        indexChild: false,
-      },
-      ...SECTIONS.map((s, i) => ({
-        section: navSection,
-        position: navPosition + i + 1,
-        label: s.label,
-        route: `/shop/${s.id}`,
-        icon: s.icon,
-        permission: { feature: 'shop', action: 'read' as const },
-      })),
-      // Clientes — top-level (route not under /shop, so it leaves the accordion).
-      // Fractional position keeps it right below "Loja", above other plugins.
-      {
-        section: navSection,
-        position: navPosition + 0.5,
-        label: CustomersNavLabel,
-        route: '/customers',
-        icon: 'Users',
-        permission: { feature: 'shop', action: 'read' as const },
-      },
-      // Canais de venda — inside the "Loja" group (route under /shop nests it in
-      // the accordion). The store's points of sale (Loja Online, WhatsApp, …).
-      {
-        section: navSection,
-        position: navPosition + SECTIONS.length + 1,
-        label: 'Canais de venda',
-        route: '/shop/channels',
-        icon: 'Radio',
-        permission: { feature: 'shop', action: 'read' as const },
-      },
-    ],
-    routes: [
-      {
-        // Kept so existing links to /shop still resolve; renders the tabbed page.
-        path: '/shop',
-        component: pageFor(),
-        permission: { feature: 'shop', action: 'read' as const },
-      },
-      ...SECTIONS.map((s) => ({
-        path: `/shop/${s.id}`,
-        component: CRUD_PAGES[s.id] ?? pageFor(s.id),
-        permission: { feature: 'shop', action: 'read' as const },
-      })),
-      // Clientes at the top level, same CRUD page as before.
-      {
-        path: '/customers',
-        component: CustomersCrudPage as React.ComponentType<unknown>,
-        permission: { feature: 'shop', action: 'read' as const },
-      },
-      // Canais de venda management page (under the Loja group).
-      {
-        path: '/shop/channels',
-        component: ChannelsPageWrapped,
-        permission: { feature: 'shop', action: 'read' as const },
-      },
-    ],
-    widgets: [],
-    aiTools: [
-      {
-        id: 'shop.list-products',
-        name: 'listProducts',
-        description: 'Lists products in the shop catalog.',
-        icon: 'Package',
-        mode: 'read' as const,
-        category: 'Shop',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            search: { type: 'string' as const, description: 'Filter by name' },
-            status: { type: 'string' as const, enum: ['draft', 'active', 'archived'] },
-          },
-        },
-        suggestions: [
-          { label: 'What products are available?' },
-          { label: 'Which products are out of stock?' },
-        ],
-      },
-      {
-        id: 'shop.list-orders',
-        name: 'listOrders',
-        description: 'Lists recent shop orders.',
-        icon: 'ShoppingCart',
-        mode: 'read' as const,
-        category: 'Shop',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            financialStatus: { type: 'string' as const, enum: ['pending', 'paid', 'refunded', 'voided'] },
-            fulfillmentStatus: { type: 'string' as const, enum: ['unfulfilled', 'partially_fulfilled', 'fulfilled'] },
-          },
-        },
-        suggestions: [
-          { label: 'Show me pending orders' },
-          { label: 'How many orders were paid today?' },
-        ],
-      },
-    ],
-    settings: [
-      {
-        id: 'shop',
-        label: 'Shop',
-        icon: 'ShoppingBag',
-        component: (() => {
-          const ShopSettingsTab: React.ComponentType<unknown> = () =>
-            React.createElement(ShopSettings, { currency: curr })
-          ShopSettingsTab.displayName = 'ShopSettingsTab'
-          return ShopSettingsTab
-        })(),
-        order: 30,
-        permission: { feature: 'shop', action: 'read' as const },
-      },
-    ],
-  }
-}
-
-// Re-export shop types so consumer apps only need @fayz-ai/plugin-shop
-export type {
-  Product, Order, ShopCustomer, Discount, Category,
-  CreateProductInput, UpdateProductInput, ListProductsOptions,
-  CreateOrderInput, UpdateOrderInput, ListOrdersOptions,
-} from '@fayz-ai/shop'