@fayz-ai/plugin-tables 0.2.0

package/src/index.ts

@@ -0,0 +1,179 @@
+import React from 'react'
+import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
+import type { TablesDataProvider } from './data/types'
+import type { TableSession } from './types'
+import { createMockTablesProvider } from './data/mock'
+import { createTablesStore } from './store'
+import { tablesRegistries } from './registries'
+import { tablesLocales } from './locales'
+import { PluginSettingsPanel } from '@fayz-ai/saas'
+
+const TablesPage = React.lazy(() => import('./TablesPage').then((m) => ({ default: m.TablesPage })))
+
+// ---------------------------------------------------------------------------
+// Labels
+// ---------------------------------------------------------------------------
+
+export interface TablesPluginLabels {
+  pageTitle: string
+  floorPlan: string
+  zones: string
+  sessionHistory: string
+}
+
+const DEFAULT_LABELS: TablesPluginLabels = {
+  pageTitle: 'Tables',
+  floorPlan: 'Floor Plan',
+  zones: 'Zones',
+  sessionHistory: 'Session History',
+}
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface TablesPluginOptions {
+  modules?: {
+    reservations?: boolean
+    sessionHistory?: boolean
+  }
+  labels?: Partial<TablesPluginLabels>
+  defaultZones?: Array<{ name: string; color?: string }>
+  navPosition?: number
+  navSection?: 'main' | 'secondary' | 'settings'
+  scope?: PluginScope
+  verticalId?: VerticalId
+  dataProvider?: TablesDataProvider
+  onTableSeated?: (session: TableSession) => Promise<string | undefined>
+  onTableClosed?: (session: TableSession) => Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Config resolver
+// ---------------------------------------------------------------------------
+
+function resolveConfig(options?: TablesPluginOptions) {
+  return {
+    modules: {
+      reservations: options?.modules?.reservations === true,
+      sessionHistory: options?.modules?.sessionHistory !== false,
+    },
+    labels: { ...DEFAULT_LABELS, ...options?.labels } as any,
+    defaultZones: options?.defaultZones ?? [
+      { name: 'Indoor', color: '#3b82f6' },
+      { name: 'Outdoor', color: '#22c55e' },
+      { name: 'Bar', color: '#f59e0b' },
+    ],
+    onTableSeated: options?.onTableSeated,
+    onTableClosed: options?.onTableClosed,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export function createTablesPlugin(options?: TablesPluginOptions): PluginManifest {
+  const config = resolveConfig(options)
+  const provider = options?.dataProvider ?? createMockTablesProvider()
+  const store = createTablesStore(provider)
+
+  const PageComponent: React.FC<any> = () =>
+    React.createElement(React.Suspense, { fallback: null },
+      React.createElement(TablesPage, { config, provider, store, registries: tablesRegistries })
+    )
+
+  return {
+    id: 'tables',
+    name: config.labels.pageTitle,
+    icon: 'MapPin',
+    version: '1.0.0',
+    scope: options?.scope ?? 'vertical',
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: [],
+    navigation: [
+      {
+        section: options?.navSection ?? 'main',
+        position: options?.navPosition ?? 4,
+        label: config.labels.pageTitle,
+        route: '/tables',
+        icon: 'MapPin',
+        permission: { feature: 'tables', action: 'read' as const },
+      },
+    ],
+    routes: [
+      {
+        path: '/tables',
+        component: PageComponent,
+        permission: { feature: 'tables', action: 'read' as const },
+      },
+    ],
+    widgets: [],
+    aiTools: [
+      {
+        id: 'tables.availability',
+        name: 'getTableAvailability',
+        description: 'Returns which tables are available, occupied, reserved, or being cleaned.',
+        icon: 'MapPin',
+        mode: 'read' as const,
+        category: 'Tables',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            zone: { type: 'string' as const, description: 'Filter by zone name' },
+            status: { type: 'string' as const, enum: ['available', 'occupied', 'reserved', 'cleaning'] },
+          },
+        },
+        suggestions: [
+          { label: 'Which tables are available right now?' },
+          { label: 'How many tables are occupied?' },
+        ],
+      },
+      {
+        id: 'tables.seat-guests',
+        name: 'seatGuests',
+        description: 'Seats guests at a specific table.',
+        icon: 'UserPlus',
+        mode: 'persist' as const,
+        category: 'Tables',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            tableNumber: { type: 'number' as const, description: 'Table number' },
+            guests: { type: 'number' as const, description: 'Number of guests' },
+          },
+          required: ['tableNumber', 'guests'],
+        },
+        permission: { feature: 'tables', action: 'edit' as const },
+      },
+    ],
+    registries: tablesRegistries,
+    settings: [
+      {
+        id: 'tables',
+        label: config.labels.pageTitle,
+        icon: 'MapPin',
+        component: (() => {
+          const TablesSettingsTab: React.ComponentType<unknown> = () =>
+            React.createElement(PluginSettingsPanel, {
+              title: 'Tables Settings',
+              subtitle: 'Zones and floor plan configuration',
+              registries: tablesRegistries,
+              routeBase: '/settings/tables',
+            })
+          TablesSettingsTab.displayName = 'TablesSettingsTab'
+          return TablesSettingsTab
+        })(),
+        order: 21,
+        permission: { feature: 'tables', action: 'read' as const },
+      },
+    ],
+    locales: tablesLocales,
+  }
+}
+
+export type { TablesDataProvider } from './data/types'
+export { createFayzTablesProvider } from './data/fayz'
+export type { FayzTablesProviderOptions } from './data/fayz'
+export type { ResolvedTablesConfig } from './TablesContext'

package/src/locales/en.ts

@@ -0,0 +1,45 @@
+export const en: Record<string, string> = {
+  'tables.title': 'Tables',
+  'tables.nav.floorPlan': 'Floor Plan',
+  'tables.nav.zones': 'Zones',
+  'tables.nav.history': 'Session History',
+  'tables.floorPlan.title': 'Floor Plan',
+  'tables.floorPlan.subtitle': 'Manage table layout and seating',
+  'tables.floorPlan.available': 'Available',
+  'tables.floorPlan.occupied': 'Occupied',
+  'tables.floorPlan.reserved': 'Reserved',
+  'tables.floorPlan.cleaning': 'Cleaning',
+  'tables.floorPlan.seats': 'seats',
+  'tables.floorPlan.noTables': 'No tables configured',
+  'tables.floorPlan.noTablesDesc': 'Add your first table to get started',
+  'tables.floorPlan.addTable': 'Add Table',
+  'tables.floorPlan.occupiedOf': '{occupied} occupied, {available} available of {total} tables',
+  'tables.floorPlan.selectTable': 'Select a table',
+  'tables.floorPlan.selectTableDesc': 'Click on any table to see details and actions',
+  'tables.floorPlan.min': 'min',
+  'tables.floorPlan.zone': 'Zone',
+  'tables.floorPlan.order': 'Order',
+  'tables.floorPlan.checkIn': 'Check In',
+  'tables.detail.currentSession': 'Current Session',
+  'tables.detail.guests': 'Guests',
+  'tables.detail.waiter': 'Waiter',
+  'tables.detail.elapsed': 'Elapsed',
+  'tables.detail.total': 'Running Total',
+  'tables.detail.viewOrder': 'View Order',
+  'tables.detail.seatGuests': 'Seat Guests',
+  'tables.detail.closeTable': 'Close Table',
+  'tables.detail.markClean': 'Mark Ready',
+  'tables.detail.cancel': 'Cancel',
+  'tables.seat.title': 'Seat Guests',
+  'tables.seat.guestCount': 'Number of guests',
+  'tables.seat.waiter': 'Waiter',
+  'tables.seat.notes': 'Notes',
+  'tables.seat.confirm': 'Seat',
+  'tables.history.title': 'Session History',
+  'tables.history.table': 'Table',
+  'tables.history.guests': 'Guests',
+  'tables.history.waiter': 'Waiter',
+  'tables.history.duration': 'Duration',
+  'tables.history.noSessions': 'No session history yet',
+  'tables.settings.title': 'Tables Settings',
+}

package/src/locales/index.ts

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

package/src/locales/pt-BR.ts

@@ -0,0 +1,45 @@
+export const ptBR: Record<string, string> = {
+  'tables.title': 'Mesas',
+  'tables.nav.floorPlan': 'Mapa de Mesas',
+  'tables.nav.zones': 'Áreas',
+  'tables.nav.history': 'Histórico',
+  'tables.floorPlan.title': 'Mapa de Mesas',
+  'tables.floorPlan.subtitle': 'Gerencie o layout e a ocupação das mesas',
+  'tables.floorPlan.available': 'Disponível',
+  'tables.floorPlan.occupied': 'Ocupada',
+  'tables.floorPlan.reserved': 'Reservada',
+  'tables.floorPlan.cleaning': 'Limpeza',
+  'tables.floorPlan.seats': 'lugares',
+  'tables.floorPlan.noTables': 'Nenhuma mesa configurada',
+  'tables.floorPlan.noTablesDesc': 'Adicione a primeira mesa para começar',
+  'tables.floorPlan.addTable': 'Adicionar Mesa',
+  'tables.floorPlan.occupiedOf': '{occupied} ocupadas, {available} disponíveis de {total} mesas',
+  'tables.floorPlan.selectTable': 'Selecione uma mesa',
+  'tables.floorPlan.selectTableDesc': 'Clique em uma mesa para ver detalhes e ações',
+  'tables.floorPlan.min': 'min',
+  'tables.floorPlan.zone': 'Área',
+  'tables.floorPlan.order': 'Pedido',
+  'tables.floorPlan.checkIn': 'Check-in',
+  'tables.detail.currentSession': 'Sessão Atual',
+  'tables.detail.guests': 'Pessoas',
+  'tables.detail.waiter': 'Garçom',
+  'tables.detail.elapsed': 'Tempo',
+  'tables.detail.total': 'Total Parcial',
+  'tables.detail.viewOrder': 'Ver Pedido',
+  'tables.detail.seatGuests': 'Sentar Clientes',
+  'tables.detail.closeTable': 'Fechar Mesa',
+  'tables.detail.markClean': 'Marcar Pronta',
+  'tables.detail.cancel': 'Cancelar',
+  'tables.seat.title': 'Sentar Clientes',
+  'tables.seat.guestCount': 'Número de pessoas',
+  'tables.seat.waiter': 'Garçom',
+  'tables.seat.notes': 'Observações',
+  'tables.seat.confirm': 'Sentar',
+  'tables.history.title': 'Histórico de Sessões',
+  'tables.history.table': 'Mesa',
+  'tables.history.guests': 'Pessoas',
+  'tables.history.waiter': 'Garçom',
+  'tables.history.duration': 'Duração',
+  'tables.history.noSessions': 'Nenhum histórico de sessões',
+  'tables.settings.title': 'Configurações de Mesas',
+}

package/src/registries.ts

@@ -0,0 +1,32 @@
+import type { PluginRegistryDef } from '@fayz-ai/core'
+import type { EntityDef } from '@fayz-ai/core'
+
+const zoneEntity: EntityDef = {
+  name: 'Zone',
+  namePlural: 'Zones',
+  icon: 'MapPin',
+  displayField: 'name',
+  defaultSort: 'sortOrder',
+  fields: [
+    { key: 'name', label: 'Name', type: 'text', required: true, showInTable: true },
+    { key: 'color', label: 'Color', type: 'text', showInTable: true },
+    { key: 'sortOrder', label: 'Order', type: 'number', showInTable: true, defaultValue: 0 },
+    { key: 'isActive', label: 'Active', type: 'boolean', showInTable: true, defaultValue: true },
+  ],
+  data: { table: 'restaurant_zones', tenantScoped: true },
+}
+
+export const tablesRegistries: PluginRegistryDef[] = [
+  {
+    id: 'zones',
+    entity: zoneEntity,
+    icon: 'MapPin',
+    description: 'Floor plan zones (indoor, outdoor, bar, etc.)',
+    display: 'table',
+    seedData: [
+      { id: 'z-indoor', name: 'Indoor', color: '#3b82f6', sortOrder: 0, isActive: true },
+      { id: 'z-outdoor', name: 'Outdoor', color: '#22c55e', sortOrder: 1, isActive: true },
+      { id: 'z-bar', name: 'Bar', color: '#f59e0b', sortOrder: 2, isActive: true },
+    ],
+  },
+]

package/src/store.ts

@@ -0,0 +1,178 @@
+import { createStore, type StoreApi } from 'zustand/vanilla'
+import { dedup } from '@fayz-ai/saas'
+import { toast } from 'sonner'
+import type { TablesDataProvider } from './data/types'
+import type {
+  RestaurantTable, TableSession, Zone,
+  CreateTableInput, SeatGuestsInput, UpdateTableStatusInput,
+  TableQuery, TablesSummary,
+} from './types'
+
+// ---------------------------------------------------------------------------
+// Store state
+// ---------------------------------------------------------------------------
+
+export interface TablesUIState {
+  // Data cache
+  tables: RestaurantTable[]
+  tablesLoading: boolean
+
+  zones: Zone[]
+  zonesLoading: boolean
+
+  activeSessions: TableSession[]
+  sessionsLoading: boolean
+
+  sessionHistory: TableSession[]
+  historyLoading: boolean
+
+  summary: TablesSummary | null
+  summaryLoading: boolean
+
+  selectedTableId: string | null
+
+  // Actions
+  fetchTables(query?: TableQuery): Promise<void>
+  fetchZones(): Promise<void>
+  fetchActiveSessions(): Promise<void>
+  fetchSessionHistory(tableId?: string): Promise<void>
+  fetchSummary(): Promise<void>
+  selectTable(id: string | null): void
+  seatGuests(input: SeatGuestsInput): Promise<TableSession>
+  closeSession(sessionId: string): Promise<void>
+  updateTableStatus(input: UpdateTableStatusInput): Promise<void>
+  createTable(input: CreateTableInput): Promise<RestaurantTable>
+}
+
+// ---------------------------------------------------------------------------
+// Store factory
+// ---------------------------------------------------------------------------
+
+export function createTablesStore(provider: TablesDataProvider): StoreApi<TablesUIState> {
+  return createStore<TablesUIState>((set, get) => ({
+    tables: [],
+    tablesLoading: false,
+
+    zones: [],
+    zonesLoading: false,
+
+    activeSessions: [],
+    sessionsLoading: false,
+
+    sessionHistory: [],
+    historyLoading: false,
+
+    summary: null,
+    summaryLoading: false,
+
+    selectedTableId: null,
+
+    async fetchTables(query) {
+      return dedup('tables:tables:' + JSON.stringify(query), async () => {
+        set({ tablesLoading: true })
+        const tables = await provider.getTables(query)
+        set({ tables, tablesLoading: false })
+      })
+    },
+
+    async fetchZones() {
+      return dedup('tables:zones', async () => {
+        set({ zonesLoading: true })
+        const zones = await provider.getZones()
+        set({ zones, zonesLoading: false })
+      })
+    },
+
+    async fetchActiveSessions() {
+      return dedup('tables:activeSessions', async () => {
+        set({ sessionsLoading: true })
+        const activeSessions = await provider.getActiveSessions()
+        set({ activeSessions, sessionsLoading: false })
+      })
+    },
+
+    async fetchSessionHistory(tableId) {
+      return dedup('tables:history:' + (tableId ?? ''), async () => {
+        set({ historyLoading: true })
+        const sessionHistory = await provider.getSessionHistory(tableId)
+        set({ sessionHistory, historyLoading: false })
+      })
+    },
+
+    async fetchSummary() {
+      return dedup('tables:summary', async () => {
+        set({ summaryLoading: true })
+        const summary = await provider.getSummary()
+        set({ summary, summaryLoading: false })
+      })
+    },
+
+    selectTable(id) {
+      set({ selectedTableId: id })
+    },
+
+    async seatGuests(input) {
+      try {
+        const session = await provider.seatGuests(input)
+        const [tables, activeSessions, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getActiveSessions(),
+          provider.getSummary(),
+        ])
+        set({ tables, activeSessions, summary })
+        toast.success('Guests seated')
+        return session
+      } catch (err: any) {
+        toast.error('Failed to seat guests', { description: err?.message })
+        throw err
+      }
+    },
+
+    async closeSession(sessionId) {
+      try {
+        await provider.closeSession(sessionId)
+        const [tables, activeSessions, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getActiveSessions(),
+          provider.getSummary(),
+        ])
+        set({ tables, activeSessions, summary })
+        toast.success('Session closed')
+      } catch (err: any) {
+        toast.error('Failed to close session', { description: err?.message })
+        throw err
+      }
+    },
+
+    async updateTableStatus(input) {
+      try {
+        await provider.updateTableStatus(input)
+        const [tables, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getSummary(),
+        ])
+        set({ tables, summary })
+        toast.success('Table status updated')
+      } catch (err: any) {
+        toast.error('Failed to update table status', { description: err?.message })
+        throw err
+      }
+    },
+
+    async createTable(input) {
+      try {
+        const table = await provider.createTable(input)
+        const [tables, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getSummary(),
+        ])
+        set({ tables, summary })
+        toast.success('Table created')
+        return table
+      } catch (err: any) {
+        toast.error('Failed to create table', { description: err?.message })
+        throw err
+      }
+    },
+  }))
+}

package/src/types.ts

@@ -0,0 +1,116 @@
+// ---------------------------------------------------------------------------
+// Tables Plugin — Pure TypeScript types
+// ---------------------------------------------------------------------------
+
+// ============================================================
+// ENUMS / LITERALS
+// ============================================================
+
+export type TableStatus = 'available' | 'occupied' | 'reserved' | 'cleaning'
+export type TableShape = 'square' | 'round' | 'rectangle' | 'bar'
+
+// ============================================================
+// CORE ENTITIES
+// ============================================================
+
+export interface RestaurantTable {
+  id: string
+  name: string
+  number: number
+  seats: number
+  status: TableStatus
+  zone: string
+  zoneName?: string
+  shape: TableShape
+  gridCol: number
+  gridRow: number
+  isActive: boolean
+  // Current session (denormalized for floor plan)
+  currentSessionId?: string
+  currentOrderId?: string
+  currentGuests?: number
+  currentWaiterName?: string
+  currentElapsedMinutes?: number
+  currentTotal?: number
+  metadata?: Record<string, unknown>
+  tenantId: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface TableSession {
+  id: string
+  tableId: string
+  tableName?: string
+  orderId?: string
+  guests: number
+  waiterId?: string
+  waiterName?: string
+  seatedAt: string
+  closedAt?: string
+  status: 'active' | 'closed'
+  notes?: string
+  tenantId: string
+  createdAt: string
+}
+
+export interface Zone {
+  id: string
+  name: string
+  color?: string
+  sortOrder: number
+  isActive: boolean
+  tenantId: string
+  createdAt: string
+}
+
+// ============================================================
+// INPUT TYPES
+// ============================================================
+
+export interface CreateTableInput {
+  name: string
+  number: number
+  seats: number
+  zone: string
+  shape?: TableShape
+  gridCol?: number
+  gridRow?: number
+}
+
+export interface SeatGuestsInput {
+  tableId: string
+  guests: number
+  waiterId?: string
+  notes?: string
+}
+
+export interface UpdateTableStatusInput {
+  tableId: string
+  status: TableStatus
+}
+
+// ============================================================
+// QUERY TYPES
+// ============================================================
+
+export interface TableQuery {
+  zone?: string
+  status?: TableStatus | TableStatus[]
+  search?: string
+}
+
+// ============================================================
+// AGGREGATION
+// ============================================================
+
+export interface TablesSummary {
+  totalTables: number
+  availableCount: number
+  occupiedCount: number
+  reservedCount: number
+  cleaningCount: number
+  totalSeats: number
+  occupiedSeats: number
+  averageSessionMinutes: number
+}