@fayz-ai/plugin-orders 0.2.0

package/src/index.ts

@@ -0,0 +1,217 @@
+import React from 'react'
+import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
+import type { EntityLookup } from '@fayz-ai/saas'
+import type { OrdersDataProvider } from './data/types'
+import type { RestaurantOrder } from './types'
+import { createMockOrdersProvider } from './data/mock'
+import { createOrdersStore } from './store'
+import { ordersRegistries } from './registries'
+import { ordersLocales } from './locales'
+import { PluginSettingsPanel } from '@fayz-ai/saas'
+
+const OrdersPage = React.lazy(() => import('./OrdersPage').then((m) => ({ default: m.OrdersPage })))
+
+// ---------------------------------------------------------------------------
+// Labels
+// ---------------------------------------------------------------------------
+
+export interface OrdersPluginLabels {
+  pageTitle: string
+  kanban: string
+  newOrder: string
+  orderList: string
+}
+
+const DEFAULT_LABELS: OrdersPluginLabels = {
+  pageTitle: 'Orders',
+  kanban: 'Orders',
+  newOrder: 'New Order',
+  orderList: 'History',
+}
+
+// ---------------------------------------------------------------------------
+// Currency + sources
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CURRENCY = { code: 'BRL', locale: 'pt-BR', symbol: 'R$' }
+
+export interface OrderSourceOption {
+  value: string
+  label: string
+  icon?: string
+}
+
+const DEFAULT_ORDER_SOURCES: OrderSourceOption[] = [
+  { value: 'dine_in', label: 'Dine-in', icon: '🍽️' },
+  { value: 'takeout', label: 'Takeout', icon: '🥡' },
+]
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface OrdersPluginOptions {
+  modules?: {
+    delivery?: boolean
+    takeout?: boolean
+  }
+  labels?: Partial<OrdersPluginLabels>
+  currency?: { code?: string; locale?: string; symbol?: string }
+  navPosition?: number
+  navSection?: 'main' | 'secondary'
+  scope?: PluginScope
+  verticalId?: VerticalId
+  dataProvider?: OrdersDataProvider
+  menuItemLookup?: EntityLookup
+  staffLookup?: EntityLookup
+  onOrderCompleted?: (order: RestaurantOrder) => Promise<void>
+  orderSources?: OrderSourceOption[]
+}
+
+// ---------------------------------------------------------------------------
+// Config resolver
+// ---------------------------------------------------------------------------
+
+function resolveConfig(options?: OrdersPluginOptions) {
+  return {
+    modules: {
+      delivery: options?.modules?.delivery !== false,
+      takeout: options?.modules?.takeout !== false,
+    },
+    labels: { ...DEFAULT_LABELS, ...options?.labels } as any,
+    currency: { ...DEFAULT_CURRENCY, ...options?.currency },
+    orderSources: options?.orderSources ?? DEFAULT_ORDER_SOURCES,
+    menuItemLookup: options?.menuItemLookup,
+    staffLookup: options?.staffLookup,
+    onOrderCompleted: options?.onOrderCompleted,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export function createOrdersPlugin(options?: OrdersPluginOptions): PluginManifest {
+  const config = resolveConfig(options)
+  const provider = options?.dataProvider ?? createMockOrdersProvider()
+  const store = createOrdersStore(provider)
+
+  const PageComponent: React.FC<any> = () =>
+    React.createElement(React.Suspense, { fallback: null },
+      React.createElement(OrdersPage, { config, provider, store, registries: ordersRegistries })
+    )
+
+  return {
+    id: 'orders',
+    name: config.labels.pageTitle,
+    icon: 'ClipboardList',
+    version: '1.0.0',
+    scope: options?.scope ?? 'vertical',
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: ['menu'],
+    navigation: [
+      {
+        section: options?.navSection ?? 'main',
+        position: options?.navPosition ?? 2,
+        label: config.labels.pageTitle,
+        route: '/orders',
+        icon: 'ClipboardList',
+        permission: { feature: 'orders', action: 'read' as const },
+      },
+    ],
+    routes: [
+      {
+        path: '/orders',
+        component: PageComponent,
+        permission: { feature: 'orders', action: 'read' as const },
+      },
+    ],
+    widgets: [],
+    aiTools: [
+      {
+        id: 'orders.today-summary',
+        name: 'getOrdersSummary',
+        description: 'Returns order count, revenue, and average ticket for today or a given period.',
+        icon: 'ClipboardList',
+        mode: 'read' as const,
+        category: 'Orders',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            period: { type: 'string' as const, description: 'today, week, month' },
+          },
+        },
+        suggestions: [
+          { label: 'How many orders today?' },
+          { label: "What's the average ticket today?" },
+          { label: "What's the most ordered item?" },
+        ],
+      },
+      {
+        id: 'orders.active-orders',
+        name: 'getActiveOrders',
+        description: 'Lists currently active (non-completed) orders.',
+        icon: 'Clock',
+        mode: 'read' as const,
+        category: 'Orders',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            kind: { type: 'string' as const, enum: ['dine_in', 'takeout', 'delivery'] },
+            status: { type: 'string' as const, description: 'Filter by status' },
+          },
+        },
+        suggestions: [
+          { label: 'What orders are being prepared right now?' },
+          { label: 'Any delivery orders waiting?' },
+        ],
+      },
+      {
+        id: 'orders.create-order',
+        name: 'createOrder',
+        description: 'Creates a new restaurant order with items.',
+        icon: 'PlusCircle',
+        mode: 'persist' as const,
+        category: 'Orders',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            kind: { type: 'string' as const, enum: ['dine_in', 'takeout', 'delivery'] },
+            tableNumber: { type: 'number' as const, description: 'Table number (for dine-in)' },
+            items: { type: 'array' as const, description: 'Item names and quantities' },
+          },
+          required: ['kind', 'items'],
+        },
+        permission: { feature: 'orders', action: 'create' as const },
+      },
+    ],
+    registries: ordersRegistries,
+    settings: [
+      {
+        id: 'orders',
+        label: config.labels.pageTitle,
+        icon: 'ClipboardList',
+        component: (() => {
+          const OrdersSettingsTab: React.ComponentType<unknown> = () =>
+            React.createElement(PluginSettingsPanel, {
+              title: 'Orders Settings',
+              subtitle: 'Order sources and preferences',
+              registries: ordersRegistries,
+              routeBase: '/settings/orders',
+            })
+          OrdersSettingsTab.displayName = 'OrdersSettingsTab'
+          return OrdersSettingsTab
+        })(),
+        order: 22,
+        permission: { feature: 'orders', action: 'read' as const },
+      },
+    ],
+    locales: ordersLocales,
+  }
+}
+
+export type { OrdersDataProvider } from './data/types'
+export { createFayzOrdersProvider } from './data/fayz'
+export type { FayzOrdersProviderOptions } from './data/fayz'
+export type { ResolvedOrdersConfig } from './OrdersContext'

package/src/locales/en.ts

@@ -0,0 +1,53 @@
+export const en: Record<string, string> = {
+  'orders.title': 'Orders',
+  'orders.nav.kanban': 'Orders',
+  'orders.nav.list': 'History',
+  'orders.nav.new': 'New Order',
+  'orders.nav.dashboard': 'Dashboard',
+  'orders.kanban.title': 'Orders',
+  'orders.kanban.subtitle': 'Active orders',
+  'orders.kanban.noOrders': 'No active orders',
+  'orders.kanban.noOrdersDesc': 'Orders will appear here as they come in',
+  'orders.kanban.newOrder': 'New Order',
+  'orders.kanban.advance': 'Advance',
+  'orders.kanban.cancel': 'Cancel Order',
+  'orders.kanban.column.new': 'New',
+  'orders.kanban.column.confirmed': 'Confirmed',
+  'orders.kanban.column.preparing': 'Preparing',
+  'orders.kanban.column.ready': 'Ready',
+  'orders.kanban.column.out': 'Out',
+  'orders.kanban.column.completed': 'Completed',
+  'orders.kanban.column.cancelled': 'Cancelled',
+  'orders.detail.title': 'Order Details',
+  'orders.detail.items': 'Items',
+  'orders.detail.table': 'Table',
+  'orders.detail.customer': 'Customer',
+  'orders.detail.waiter': 'Waiter',
+  'orders.detail.source': 'Source',
+  'orders.detail.subtotal': 'Subtotal',
+  'orders.detail.discount': 'Discount',
+  'orders.detail.tax': 'Tax',
+  'orders.detail.total': 'Total',
+  'orders.detail.notes': 'Notes',
+  'orders.newOrder.title': 'New Order',
+  'orders.newOrder.selectKind': 'Order type',
+  'orders.newOrder.dineIn': 'Dine-in',
+  'orders.newOrder.takeout': 'Takeout',
+  'orders.newOrder.delivery': 'Delivery',
+  'orders.newOrder.selectTable': 'Select table',
+  'orders.newOrder.addItems': 'Add items',
+  'orders.newOrder.searchItems': 'Search menu...',
+  'orders.newOrder.noItems': 'No items added yet',
+  'orders.newOrder.confirm': 'Place Order',
+  'orders.newOrder.cancel': 'Cancel',
+  'orders.list.title': 'Order History',
+  'orders.list.subtitle': 'All orders',
+  'orders.list.search': 'Search orders...',
+  'orders.list.noOrders': 'No orders found',
+  'orders.source.dine_in': 'Dine-in',
+  'orders.source.takeout': 'Takeout',
+  'orders.source.ifood': 'iFood',
+  'orders.source.99food': '99Food',
+  'orders.source.delivery': 'Delivery',
+  'orders.settings.title': 'Orders Settings',
+}

package/src/locales/index.ts

@@ -0,0 +1,4 @@
+import { en } from './en'
+import { ptBR } from './pt-BR'
+
+export const ordersLocales: Record<string, Record<string, string>> = { en, 'pt-BR': ptBR }

package/src/locales/pt-BR.ts

@@ -0,0 +1,53 @@
+export const ptBR: Record<string, string> = {
+  'orders.title': 'Pedidos',
+  'orders.nav.kanban': 'Pedidos',
+  'orders.nav.list': 'Histórico',
+  'orders.nav.new': 'Novo Pedido',
+  'orders.nav.dashboard': 'Painel',
+  'orders.kanban.title': 'Pedidos',
+  'orders.kanban.subtitle': 'Pedidos ativos',
+  'orders.kanban.noOrders': 'Nenhum pedido ativo',
+  'orders.kanban.noOrdersDesc': 'Os pedidos aparecerão aqui conforme chegarem',
+  'orders.kanban.newOrder': 'Novo Pedido',
+  'orders.kanban.advance': 'Avançar',
+  'orders.kanban.cancel': 'Cancelar Pedido',
+  'orders.kanban.column.new': 'Novo',
+  'orders.kanban.column.confirmed': 'Confirmado',
+  'orders.kanban.column.preparing': 'Preparando',
+  'orders.kanban.column.ready': 'Pronto',
+  'orders.kanban.column.out': 'Saiu',
+  'orders.kanban.column.completed': 'Concluído',
+  'orders.kanban.column.cancelled': 'Cancelado',
+  'orders.detail.title': 'Detalhes do Pedido',
+  'orders.detail.items': 'Itens',
+  'orders.detail.table': 'Mesa',
+  'orders.detail.customer': 'Cliente',
+  'orders.detail.waiter': 'Garçom',
+  'orders.detail.source': 'Origem',
+  'orders.detail.subtotal': 'Subtotal',
+  'orders.detail.discount': 'Desconto',
+  'orders.detail.tax': 'Imposto',
+  'orders.detail.total': 'Total',
+  'orders.detail.notes': 'Observações',
+  'orders.newOrder.title': 'Novo Pedido',
+  'orders.newOrder.selectKind': 'Tipo de pedido',
+  'orders.newOrder.dineIn': 'Mesa',
+  'orders.newOrder.takeout': 'Para Viagem',
+  'orders.newOrder.delivery': 'Delivery',
+  'orders.newOrder.selectTable': 'Selecionar mesa',
+  'orders.newOrder.addItems': 'Adicionar itens',
+  'orders.newOrder.searchItems': 'Buscar no cardápio...',
+  'orders.newOrder.noItems': 'Nenhum item adicionado',
+  'orders.newOrder.confirm': 'Fazer Pedido',
+  'orders.newOrder.cancel': 'Cancelar',
+  'orders.list.title': 'Histórico de Pedidos',
+  'orders.list.subtitle': 'Todos os pedidos',
+  'orders.list.search': 'Buscar pedidos...',
+  'orders.list.noOrders': 'Nenhum pedido encontrado',
+  'orders.source.dine_in': 'Mesa',
+  'orders.source.takeout': 'Para Viagem',
+  'orders.source.ifood': 'iFood',
+  'orders.source.99food': '99Food',
+  'orders.source.delivery': 'Delivery',
+  'orders.settings.title': 'Configurações de Pedidos',
+}

package/src/registries.ts

@@ -0,0 +1,32 @@
+import type { PluginRegistryDef } from '@fayz-ai/core'
+import type { EntityDef } from '@fayz-ai/core'
+
+const orderSourceEntity: EntityDef = {
+  name: 'Order Source',
+  namePlural: 'Order Sources',
+  icon: 'Globe',
+  displayField: 'name',
+  defaultSort: 'name',
+  fields: [
+    { key: 'name', label: 'Name', type: 'text', required: true, showInTable: true },
+    { key: 'icon', label: 'Icon', type: 'text', showInTable: true },
+    { key: 'isActive', label: 'Active', type: 'boolean', showInTable: true, defaultValue: true },
+  ],
+  data: { table: 'order_sources', tenantScoped: true },
+}
+
+export const ordersRegistries: PluginRegistryDef[] = [
+  {
+    id: 'order-sources',
+    entity: orderSourceEntity,
+    icon: 'Globe',
+    description: 'Order sources and delivery platforms',
+    display: 'table',
+    seedData: [
+      { id: 'os-dine', name: 'Dine-in', icon: '🍽️', isActive: true },
+      { id: 'os-takeout', name: 'Takeout', icon: '🥡', isActive: true },
+      { id: 'os-ifood', name: 'iFood', icon: '🔴', isActive: true },
+      { id: 'os-99food', name: '99Food', icon: '🟡', isActive: true },
+    ],
+  },
+]

package/src/store.ts

@@ -0,0 +1,191 @@
+import { createStore, type StoreApi } from 'zustand/vanilla'
+import { dedup } from '@fayz-ai/saas'
+import { toast } from 'sonner'
+import type { OrdersDataProvider } from './data/types'
+import type {
+  RestaurantOrder, OrdersSummary,
+  OrderQuery, CreateOrderInput, CreateOrderItemInput,
+  UpdateOrderStatusInput,
+} from './types'
+import { getNextStatus } from './types'
+
+// ---------------------------------------------------------------------------
+// Store state
+// ---------------------------------------------------------------------------
+
+export interface OrdersUIState {
+  // Data cache
+  orders: RestaurantOrder[]
+  ordersTotal: number
+  ordersLoading: boolean
+  orderQuery: OrderQuery
+
+  activeOrders: RestaurantOrder[]
+  activeOrdersLoading: boolean
+
+  summary: OrdersSummary | null
+  summaryLoading: boolean
+
+  selectedOrderId: string | null
+
+  // Actions
+  fetchOrders(query: OrderQuery): Promise<void>
+  fetchActiveOrders(): Promise<void>
+  fetchSummary(dateRange?: { from: string; to: string }): Promise<void>
+  selectOrder(id: string | null): void
+  createOrder(input: CreateOrderInput): Promise<RestaurantOrder>
+  advanceOrderStatus(orderId: string): Promise<void>
+  updateOrderStatus(input: UpdateOrderStatusInput): Promise<void>
+  cancelOrder(id: string, reason?: string): Promise<void>
+  addOrderItem(orderId: string, item: CreateOrderItemInput): Promise<void>
+  removeOrderItem(itemId: string): Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Store factory
+// ---------------------------------------------------------------------------
+
+export function createOrdersStore(provider: OrdersDataProvider): StoreApi<OrdersUIState> {
+  return createStore<OrdersUIState>((set, get) => ({
+    orders: [],
+    ordersTotal: 0,
+    ordersLoading: false,
+    orderQuery: {},
+
+    activeOrders: [],
+    activeOrdersLoading: false,
+
+    summary: null,
+    summaryLoading: false,
+
+    selectedOrderId: null,
+
+    async fetchOrders(query) {
+      return dedup('orders:list:' + JSON.stringify(query), async () => {
+        set({ ordersLoading: true, orderQuery: query })
+        const result = await provider.getOrders(query)
+        set({ orders: result.data, ordersTotal: result.total, ordersLoading: false })
+      })
+    },
+
+    async fetchActiveOrders() {
+      return dedup('orders:active', async () => {
+        set({ activeOrdersLoading: true })
+        const result = await provider.getOrders({
+          status: ['new', 'confirmed', 'preparing', 'ready'],
+        })
+        set({ activeOrders: result.data, activeOrdersLoading: false })
+      })
+    },
+
+    async fetchSummary(dateRange) {
+      return dedup('orders:summary', async () => {
+        set({ summaryLoading: true })
+        const summary = await provider.getSummary(dateRange)
+        set({ summary, summaryLoading: false })
+      })
+    },
+
+    selectOrder(id) {
+      set({ selectedOrderId: id })
+    },
+
+    async createOrder(input) {
+      try {
+        const order = await provider.createOrder(input)
+        const query = get().orderQuery
+        const [result, summary] = await Promise.all([
+          provider.getOrders(query),
+          provider.getSummary(),
+        ])
+        set({ orders: result.data, ordersTotal: result.total, summary })
+        toast.success('Order created')
+        return order
+      } catch (err: any) {
+        toast.error('Failed to create order', { description: err?.message })
+        throw err
+      }
+    },
+
+    async advanceOrderStatus(orderId) {
+      try {
+        const { orders, activeOrders } = get()
+        const order = orders.find(o => o.id === orderId) ?? activeOrders.find(o => o.id === orderId)
+        if (!order) throw new Error('Order not found')
+
+        const nextStatus = getNextStatus(order.kind, order.status)
+        if (!nextStatus) throw new Error('No next status available')
+
+        await provider.updateOrderStatus({ orderId, status: nextStatus })
+
+        // Refresh active orders
+        const activeResult = await provider.getOrders({
+          status: ['new', 'confirmed', 'preparing', 'ready'],
+        })
+        set({ activeOrders: activeResult.data })
+        toast.success(`Order advanced to ${nextStatus.replace('_', ' ')}`)
+      } catch (err: any) {
+        toast.error('Failed to advance order', { description: err?.message })
+        throw err
+      }
+    },
+
+    async updateOrderStatus(input) {
+      try {
+        await provider.updateOrderStatus(input)
+        const query = get().orderQuery
+        const [result, summary] = await Promise.all([
+          provider.getOrders(query),
+          provider.getSummary(),
+        ])
+        set({ orders: result.data, ordersTotal: result.total, summary })
+        toast.success('Order status updated')
+      } catch (err: any) {
+        toast.error('Failed to update status', { description: err?.message })
+        throw err
+      }
+    },
+
+    async cancelOrder(id, reason) {
+      try {
+        await provider.cancelOrder(id, reason)
+        const query = get().orderQuery
+        const [result, summary] = await Promise.all([
+          provider.getOrders(query),
+          provider.getSummary(),
+        ])
+        set({ orders: result.data, ordersTotal: result.total, summary })
+        toast.success('Order cancelled')
+      } catch (err: any) {
+        toast.error('Failed to cancel order', { description: err?.message })
+        throw err
+      }
+    },
+
+    async addOrderItem(orderId, item) {
+      try {
+        await provider.addOrderItem(orderId, item)
+        const query = get().orderQuery
+        const result = await provider.getOrders(query)
+        set({ orders: result.data, ordersTotal: result.total })
+        toast.success('Item added')
+      } catch (err: any) {
+        toast.error('Failed to add item', { description: err?.message })
+        throw err
+      }
+    },
+
+    async removeOrderItem(itemId) {
+      try {
+        await provider.removeOrderItem(itemId)
+        const query = get().orderQuery
+        const result = await provider.getOrders(query)
+        set({ orders: result.data, ordersTotal: result.total })
+        toast.success('Item removed')
+      } catch (err: any) {
+        toast.error('Failed to remove item', { description: err?.message })
+        throw err
+      }
+    },
+  }))
+}