@fayz-ai/plugin-tables 0.2.0

package/src/data/fayz.ts

@@ -0,0 +1,348 @@
+import { createFayzClient, type FayzClientOptions, type FayzTableFilter } from '@fayz-ai/sdk'
+import type {
+  CreateTableInput,
+  RestaurantTable,
+  SeatGuestsInput,
+  TableQuery,
+  TableSession,
+  TablesSummary,
+  TableStatus,
+  UpdateTableStatusInput,
+  Zone,
+} from '../types'
+import type { TablesDataProvider } from './types'
+
+export interface FayzTablesProviderOptions extends FayzClientOptions {
+  projectId?: string
+  tableName?: string
+  schema?: string
+  runtime?: boolean
+  /**
+   * Active tenant id (or a getter) used to scope reads and stamp writes on the
+   * restaurant_tables table. When omitted, scoping is left to runtime/RLS.
+   */
+  tenantId?: string | (() => string | undefined | null)
+}
+
+interface RestaurantTableRow {
+  id: string
+  tenant_id?: string | null
+  name?: string | null
+  number?: number | null
+  seats?: number | null
+  status?: TableStatus | null
+  zone?: string | null
+  zone_name?: string | null
+  shape?: RestaurantTable['shape'] | null
+  grid_col?: number | null
+  grid_row?: number | null
+  is_active?: boolean | null
+  current_session_id?: string | null
+  current_order_id?: string | null
+  current_guests?: number | null
+  current_waiter_name?: string | null
+  current_elapsed_minutes?: number | null
+  current_total?: number | null
+  metadata?: Record<string, unknown> | null
+  created_at?: string | null
+  updated_at?: string | null
+}
+
+const DEFAULT_TABLE_NAME = 'restaurant_tables'
+
+function nowIso(): string {
+  return new Date().toISOString()
+}
+
+function rowToTable(row: RestaurantTableRow): RestaurantTable {
+  const number = row.number ?? 0
+  const zone = row.zone ?? 'indoor'
+  return {
+    id: row.id,
+    name: row.name ?? `Table ${number}`,
+    number,
+    seats: row.seats ?? 4,
+    status: row.status ?? 'available',
+    zone,
+    zoneName: row.zone_name ?? zone,
+    shape: row.shape ?? 'square',
+    gridCol: row.grid_col ?? 0,
+    gridRow: row.grid_row ?? 0,
+    isActive: row.is_active ?? true,
+    currentSessionId: row.current_session_id ?? undefined,
+    currentOrderId: row.current_order_id ?? undefined,
+    currentGuests: row.current_guests ?? undefined,
+    currentWaiterName: row.current_waiter_name ?? undefined,
+    currentElapsedMinutes: row.current_elapsed_minutes ?? undefined,
+    currentTotal: row.current_total ?? undefined,
+    metadata: row.metadata ?? {},
+    tenantId: row.tenant_id ?? 'runtime-tenant',
+    createdAt: row.created_at ?? nowIso(),
+    updatedAt: row.updated_at ?? row.created_at ?? nowIso(),
+  }
+}
+
+function tableCreatePayload(input: CreateTableInput): Record<string, unknown> {
+  return {
+    name: input.name,
+    number: input.number,
+    seats: input.seats,
+    zone: input.zone,
+    shape: input.shape ?? 'square',
+    grid_col: input.gridCol ?? 0,
+    grid_row: input.gridRow ?? 0,
+    status: 'available',
+    is_active: true,
+  }
+}
+
+function tableUpdatePayload(data: Partial<RestaurantTable>): Record<string, unknown> {
+  const payload: Record<string, unknown> = {}
+  if (data.name !== undefined) payload.name = data.name
+  if (data.number !== undefined) payload.number = data.number
+  if (data.seats !== undefined) payload.seats = data.seats
+  if (data.status !== undefined) payload.status = data.status
+  if (data.zone !== undefined) payload.zone = data.zone
+  if (data.zoneName !== undefined) payload.zone_name = data.zoneName
+  if (data.shape !== undefined) payload.shape = data.shape
+  if (data.gridCol !== undefined) payload.grid_col = data.gridCol
+  if (data.gridRow !== undefined) payload.grid_row = data.gridRow
+  if (data.isActive !== undefined) payload.is_active = data.isActive
+  if (data.currentSessionId !== undefined) payload.current_session_id = data.currentSessionId
+  if (data.currentOrderId !== undefined) payload.current_order_id = data.currentOrderId
+  if (data.currentGuests !== undefined) payload.current_guests = data.currentGuests
+  if (data.currentWaiterName !== undefined) payload.current_waiter_name = data.currentWaiterName
+  if (data.currentElapsedMinutes !== undefined) payload.current_elapsed_minutes = data.currentElapsedMinutes
+  if (data.currentTotal !== undefined) payload.current_total = data.currentTotal
+  if (data.metadata !== undefined) payload.metadata = data.metadata
+  return payload
+}
+
+function filtersFromQuery(query?: TableQuery): FayzTableFilter[] {
+  const filters: FayzTableFilter[] = [{ column: 'is_active', operator: 'eq', value: true }]
+  if (!query) return filters
+  if (query.zone) filters.push({ column: 'zone', operator: 'eq', value: query.zone })
+  if (query.status && !Array.isArray(query.status)) {
+    filters.push({ column: 'status', operator: 'eq', value: query.status })
+  }
+  return filters
+}
+
+function matchesClientQuery(table: RestaurantTable, query?: TableQuery): boolean {
+  if (!query) return true
+  if (Array.isArray(query.status) && !query.status.includes(table.status)) return false
+  if (query.search) {
+    const search = query.search.toLowerCase()
+    return table.name.toLowerCase().includes(search)
+      || String(table.number).includes(search)
+      || (table.zoneName?.toLowerCase().includes(search) ?? false)
+  }
+  return true
+}
+
+function summarize(tables: RestaurantTable[]): TablesSummary {
+  const availableCount = tables.filter((table) => table.status === 'available').length
+  const occupiedCount = tables.filter((table) => table.status === 'occupied').length
+  const reservedCount = tables.filter((table) => table.status === 'reserved').length
+  const cleaningCount = tables.filter((table) => table.status === 'cleaning').length
+  const totalSeats = tables.reduce((sum, table) => sum + table.seats, 0)
+  const occupiedSeats = tables
+    .filter((table) => table.status === 'occupied')
+    .reduce((sum, table) => sum + (table.currentGuests ?? table.seats), 0)
+
+  return {
+    totalTables: tables.length,
+    availableCount,
+    occupiedCount,
+    reservedCount,
+    cleaningCount,
+    totalSeats,
+    occupiedSeats,
+    averageSessionMinutes: 0,
+  }
+}
+
+export function createFayzTablesProvider(options: FayzTablesProviderOptions = {}): TablesDataProvider {
+  const client = createFayzClient(options)
+  const table = options.tableName ?? DEFAULT_TABLE_NAME
+  const baseOptions = {
+    projectId: options.projectId,
+    table,
+    schema: options.schema,
+    runtime: options.runtime,
+  }
+
+  function resolveTenant(): string | undefined {
+    const value = typeof options.tenantId === 'function' ? options.tenantId() : options.tenantId
+    return value ?? undefined
+  }
+
+  function withTenant(filters: FayzTableFilter[]): FayzTableFilter[] {
+    const tenantId = resolveTenant()
+    return tenantId ? [{ column: 'tenant_id', operator: 'eq', value: tenantId }, ...filters] : filters
+  }
+
+  async function listTables(query?: TableQuery): Promise<RestaurantTable[]> {
+    const response = await client.data.listRows<RestaurantTableRow>({
+      ...baseOptions,
+      filters: withTenant(filtersFromQuery(query)),
+      sortColumn: 'number',
+      sortDirection: 'asc',
+      limit: 500,
+    })
+    return response.rows.map(rowToTable).filter((item) => matchesClientQuery(item, query))
+  }
+
+  async function getById(id: string): Promise<RestaurantTable | null> {
+    const response = await client.data.listRows<RestaurantTableRow>({
+      ...baseOptions,
+      filters: withTenant([{ column: 'id', operator: 'eq', value: id }]),
+      limit: 1,
+    })
+    return response.rows[0] ? rowToTable(response.rows[0]) : null
+  }
+
+  return {
+    async getTables(query?: TableQuery) {
+      return listTables(query)
+    },
+
+    async getTableById(id: string) {
+      return getById(id)
+    },
+
+    async createTable(input: CreateTableInput) {
+      const tenantId = resolveTenant()
+      const row = await client.data.createRow<RestaurantTableRow>({
+        ...baseOptions,
+        row: tenantId ? { ...tableCreatePayload(input), tenant_id: tenantId } : tableCreatePayload(input),
+      })
+      return rowToTable(row)
+    },
+
+    async updateTable(id: string, data: Partial<RestaurantTable>) {
+      const row = await client.data.updateRow<RestaurantTableRow>({
+        ...baseOptions,
+        primaryKeys: { id },
+        row: tableUpdatePayload(data),
+      })
+      return rowToTable(row)
+    },
+
+    async deleteTable(id: string) {
+      await client.data.deleteRows({ ...baseOptions, rows: [{ id }] })
+    },
+
+    async updateTableStatus(input: UpdateTableStatusInput) {
+      return this.updateTable(input.tableId, { status: input.status })
+    },
+
+    async updateTablePositions(positions: Array<{ id: string; gridCol: number; gridRow: number }>) {
+      await Promise.all(positions.map((position) => this.updateTable(position.id, {
+        gridCol: position.gridCol,
+        gridRow: position.gridRow,
+      })))
+    },
+
+    async seatGuests(input: SeatGuestsInput) {
+      const table = await this.updateTable(input.tableId, {
+        status: 'occupied',
+        currentGuests: input.guests,
+        currentWaiterName: input.waiterId ? `Waiter ${input.waiterId}` : undefined,
+        currentElapsedMinutes: 0,
+        currentTotal: 0,
+      })
+      const session: TableSession = {
+        id: table.currentSessionId ?? `runtime-session-${table.id}`,
+        tableId: table.id,
+        tableName: table.name,
+        guests: input.guests,
+        waiterId: input.waiterId,
+        waiterName: table.currentWaiterName,
+        seatedAt: nowIso(),
+        status: 'active',
+        notes: input.notes,
+        tenantId: table.tenantId,
+        createdAt: nowIso(),
+      }
+      return session
+    },
+
+    async closeSession(sessionId: string) {
+      const tables = await listTables()
+      const table = tables.find((item) => item.currentSessionId === sessionId)
+      if (table) await this.updateTable(table.id, {
+        status: 'cleaning',
+        currentSessionId: undefined,
+        currentOrderId: undefined,
+        currentGuests: undefined,
+        currentWaiterName: undefined,
+        currentElapsedMinutes: undefined,
+        currentTotal: undefined,
+      })
+      return {
+        id: sessionId,
+        tableId: table?.id ?? '',
+        tableName: table?.name,
+        guests: table?.currentGuests ?? 0,
+        seatedAt: nowIso(),
+        closedAt: nowIso(),
+        status: 'closed',
+        tenantId: table?.tenantId ?? 'runtime-tenant',
+        createdAt: nowIso(),
+      }
+    },
+
+    async getActiveSessions() {
+      const tables = await listTables({ status: 'occupied' })
+      return tables.map((table) => ({
+        id: table.currentSessionId ?? `runtime-session-${table.id}`,
+        tableId: table.id,
+        tableName: table.name,
+        guests: table.currentGuests ?? table.seats,
+        waiterName: table.currentWaiterName,
+        seatedAt: nowIso(),
+        status: 'active' as const,
+        tenantId: table.tenantId,
+        createdAt: nowIso(),
+      }))
+    },
+
+    async getSessionHistory() {
+      return []
+    },
+
+    async getZones() {
+      const tables = await listTables()
+      const zones = new Map<string, Zone>()
+      for (const table of tables) {
+        if (zones.has(table.zone)) continue
+        zones.set(table.zone, {
+          id: table.zone,
+          name: table.zoneName ?? table.zone,
+          sortOrder: zones.size,
+          isActive: true,
+          tenantId: table.tenantId,
+          createdAt: table.createdAt,
+        })
+      }
+      return [...zones.values()]
+    },
+
+    async createZone() {
+      throw new Error('Restaurant zone writes require a dedicated Fayz table/broker contract.')
+    },
+
+    async updateZone() {
+      throw new Error('Restaurant zone writes require a dedicated Fayz table/broker contract.')
+    },
+
+    async deleteZone() {
+      throw new Error('Restaurant zone writes require a dedicated Fayz table/broker contract.')
+    },
+
+    async getSummary() {
+      return summarize(await listTables())
+    },
+  }
+}

package/src/data/mock.ts

@@ -0,0 +1,322 @@
+import type {
+  RestaurantTable, TableSession, Zone,
+  CreateTableInput, SeatGuestsInput, UpdateTableStatusInput,
+  TableQuery, TablesSummary, TableShape,
+} from '../types'
+import type { TablesDataProvider } from './types'
+
+// ---------------------------------------------------------------------------
+// ID generator
+// ---------------------------------------------------------------------------
+
+let uid = 0
+function nextId(prefix: string) { return prefix + '-' + (++uid) }
+
+// ---------------------------------------------------------------------------
+// Seed helpers
+// ---------------------------------------------------------------------------
+
+const TENANT = 'mock-tenant'
+const NOW = new Date().toISOString()
+
+function makeTable(
+  id: string,
+  number: number,
+  seats: number,
+  zone: string,
+  zoneName: string,
+  shape: TableShape,
+  gridCol: number,
+  gridRow: number,
+): RestaurantTable {
+  return {
+    id,
+    name: `Table ${number}`,
+    number,
+    seats,
+    status: 'available',
+    zone,
+    zoneName,
+    shape,
+    gridCol,
+    gridRow,
+    isActive: true,
+    tenantId: TENANT,
+    createdAt: NOW,
+    updatedAt: NOW,
+  }
+}
+
+function seedZones(): Zone[] {
+  return [
+    { id: nextId('zone'), name: 'Indoor',  color: '#3b82f6', sortOrder: 0, isActive: true, tenantId: TENANT, createdAt: NOW },
+    { id: nextId('zone'), name: 'Outdoor', color: '#22c55e', sortOrder: 1, isActive: true, tenantId: TENANT, createdAt: NOW },
+    { id: nextId('zone'), name: 'Bar',     color: '#f59e0b', sortOrder: 2, isActive: true, tenantId: TENANT, createdAt: NOW },
+  ]
+}
+
+function seedTables(zones: Zone[]): RestaurantTable[] {
+  const [indoor, outdoor, bar] = zones
+
+  const tables: RestaurantTable[] = []
+
+  // Indoor zone — tables 1-8, 4x2 grid, alternating 4/6 seats, square/rectangle
+  for (let i = 0; i < 8; i++) {
+    const num = i + 1
+    tables.push(makeTable(
+      nextId('table'),
+      num,
+      i % 2 === 0 ? 4 : 6,
+      indoor.id,
+      indoor.name,
+      i % 2 === 0 ? 'square' : 'rectangle',
+      (i % 4),
+      Math.floor(i / 4),
+    ))
+  }
+
+  // Outdoor zone — tables 9-10, round, 4 seats
+  tables.push(makeTable(nextId('table'), 9,  4, outdoor.id, outdoor.name, 'round', 0, 0))
+  tables.push(makeTable(nextId('table'), 10, 4, outdoor.id, outdoor.name, 'round', 1, 0))
+
+  // Bar zone — tables 11-12, bar shape, 2 seats
+  tables.push(makeTable(nextId('table'), 11, 2, bar.id, bar.name, 'bar', 0, 0))
+  tables.push(makeTable(nextId('table'), 12, 2, bar.id, bar.name, 'bar', 1, 0))
+
+  return tables
+}
+
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+
+export function createMockTablesProvider(): TablesDataProvider {
+  const zones = seedZones()
+  const tables = seedTables(zones)
+  const sessions: TableSession[] = []
+
+  // ------- helpers -------
+
+  function findTable(id: string) {
+    return tables.find(t => t.id === id) ?? null
+  }
+
+  function matchesQuery(table: RestaurantTable, query?: TableQuery): boolean {
+    if (!query) return true
+    if (query.zone && table.zone !== query.zone) return false
+    if (query.status) {
+      const statuses = Array.isArray(query.status) ? query.status : [query.status]
+      if (!statuses.includes(table.status)) return false
+    }
+    if (query.search) {
+      const s = query.search.toLowerCase()
+      if (
+        !table.name.toLowerCase().includes(s) &&
+        !String(table.number).includes(s) &&
+        !(table.zoneName ?? '').toLowerCase().includes(s)
+      ) return false
+    }
+    return true
+  }
+
+  // ------- provider -------
+
+  return {
+    // ---- Tables ----
+
+    async getTables(query?: TableQuery) {
+      return tables.filter(t => matchesQuery(t, query))
+    },
+
+    async getTableById(id: string) {
+      return findTable(id)
+    },
+
+    async createTable(input: CreateTableInput) {
+      const zone = zones.find(z => z.id === input.zone)
+      const table: RestaurantTable = {
+        id: nextId('table'),
+        name: input.name,
+        number: input.number,
+        seats: input.seats,
+        status: 'available',
+        zone: input.zone,
+        zoneName: zone?.name,
+        shape: input.shape ?? 'square',
+        gridCol: input.gridCol ?? 0,
+        gridRow: input.gridRow ?? 0,
+        isActive: true,
+        tenantId: TENANT,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+      tables.push(table)
+      return table
+    },
+
+    async updateTable(id: string, data: Partial<RestaurantTable>) {
+      const table = findTable(id)
+      if (!table) throw new Error(`Table ${id} not found`)
+      Object.assign(table, data, { updatedAt: new Date().toISOString() })
+      return table
+    },
+
+    async deleteTable(id: string) {
+      const idx = tables.findIndex(t => t.id === id)
+      if (idx !== -1) tables.splice(idx, 1)
+    },
+
+    async updateTableStatus(input: UpdateTableStatusInput) {
+      const table = findTable(input.tableId)
+      if (!table) throw new Error(`Table ${input.tableId} not found`)
+      table.status = input.status
+      table.updatedAt = new Date().toISOString()
+      return table
+    },
+
+    async updateTablePositions(positions: Array<{ id: string; gridCol: number; gridRow: number }>) {
+      for (const pos of positions) {
+        const table = findTable(pos.id)
+        if (table) {
+          table.gridCol = pos.gridCol
+          table.gridRow = pos.gridRow
+          table.updatedAt = new Date().toISOString()
+        }
+      }
+    },
+
+    // ---- Sessions ----
+
+    async seatGuests(input: SeatGuestsInput) {
+      const table = findTable(input.tableId)
+      if (!table) throw new Error(`Table ${input.tableId} not found`)
+
+      const session: TableSession = {
+        id: nextId('session'),
+        tableId: input.tableId,
+        tableName: table.name,
+        guests: input.guests,
+        waiterId: input.waiterId,
+        waiterName: input.waiterId ? `Waiter ${input.waiterId}` : undefined,
+        seatedAt: new Date().toISOString(),
+        status: 'active',
+        notes: input.notes,
+        tenantId: TENANT,
+        createdAt: new Date().toISOString(),
+      }
+      sessions.push(session)
+
+      // Denormalize onto table
+      table.status = 'occupied'
+      table.currentSessionId = session.id
+      table.currentGuests = input.guests
+      table.currentWaiterName = session.waiterName
+      table.currentElapsedMinutes = 0
+      table.currentTotal = 0
+      table.updatedAt = new Date().toISOString()
+
+      return session
+    },
+
+    async closeSession(sessionId: string) {
+      const session = sessions.find(s => s.id === sessionId)
+      if (!session) throw new Error(`Session ${sessionId} not found`)
+
+      session.status = 'closed'
+      session.closedAt = new Date().toISOString()
+
+      // Update table → cleaning
+      const table = findTable(session.tableId)
+      if (table) {
+        table.status = 'cleaning'
+        table.currentSessionId = undefined
+        table.currentOrderId = undefined
+        table.currentGuests = undefined
+        table.currentWaiterName = undefined
+        table.currentElapsedMinutes = undefined
+        table.currentTotal = undefined
+        table.updatedAt = new Date().toISOString()
+      }
+
+      return session
+    },
+
+    async getActiveSessions() {
+      return sessions.filter(s => s.status === 'active')
+    },
+
+    async getSessionHistory(tableId?: string) {
+      const closed = sessions.filter(s => s.status === 'closed')
+      if (tableId) return closed.filter(s => s.tableId === tableId)
+      return closed
+    },
+
+    // ---- Zones ----
+
+    async getZones() {
+      return [...zones]
+    },
+
+    async createZone(data: Partial<Zone>) {
+      const zone: Zone = {
+        id: nextId('zone'),
+        name: data.name ?? 'New Zone',
+        color: data.color,
+        sortOrder: data.sortOrder ?? zones.length,
+        isActive: data.isActive ?? true,
+        tenantId: TENANT,
+        createdAt: new Date().toISOString(),
+      }
+      zones.push(zone)
+      return zone
+    },
+
+    async updateZone(id: string, data: Partial<Zone>) {
+      const zone = zones.find(z => z.id === id)
+      if (!zone) throw new Error(`Zone ${id} not found`)
+      Object.assign(zone, data)
+      return zone
+    },
+
+    async deleteZone(id: string) {
+      const idx = zones.findIndex(z => z.id === id)
+      if (idx !== -1) zones.splice(idx, 1)
+    },
+
+    // ---- Summary ----
+
+    async getSummary(): Promise<TablesSummary> {
+      const available = tables.filter(t => t.status === 'available').length
+      const occupied = tables.filter(t => t.status === 'occupied').length
+      const reserved = tables.filter(t => t.status === 'reserved').length
+      const cleaning = tables.filter(t => t.status === 'cleaning').length
+
+      const totalSeats = tables.reduce((sum, t) => sum + t.seats, 0)
+      const occupiedSeats = tables
+        .filter(t => t.status === 'occupied')
+        .reduce((sum, t) => sum + (t.currentGuests ?? t.seats), 0)
+
+      const closedSessions = sessions.filter(s => s.status === 'closed' && s.closedAt)
+      let averageSessionMinutes = 0
+      if (closedSessions.length > 0) {
+        const totalMinutes = closedSessions.reduce((sum, s) => {
+          const seated = new Date(s.seatedAt).getTime()
+          const closed = new Date(s.closedAt!).getTime()
+          return sum + (closed - seated) / 60_000
+        }, 0)
+        averageSessionMinutes = Math.round(totalMinutes / closedSessions.length)
+      }
+
+      return {
+        totalTables: tables.length,
+        availableCount: available,
+        occupiedCount: occupied,
+        reservedCount: reserved,
+        cleaningCount: cleaning,
+        totalSeats,
+        occupiedSeats,
+        averageSessionMinutes,
+      }
+    },
+  }
+}

package/src/data/types.ts

@@ -0,0 +1,31 @@
+import type {
+  RestaurantTable, TableSession, Zone,
+  CreateTableInput, SeatGuestsInput, UpdateTableStatusInput,
+  TableQuery, TablesSummary,
+} from '../types'
+
+export interface TablesDataProvider {
+  // Tables
+  getTables(query?: TableQuery): Promise<RestaurantTable[]>
+  getTableById(id: string): Promise<RestaurantTable | null>
+  createTable(input: CreateTableInput): Promise<RestaurantTable>
+  updateTable(id: string, data: Partial<RestaurantTable>): Promise<RestaurantTable>
+  deleteTable(id: string): Promise<void>
+  updateTableStatus(input: UpdateTableStatusInput): Promise<RestaurantTable>
+  updateTablePositions(positions: Array<{ id: string; gridCol: number; gridRow: number }>): Promise<void>
+
+  // Sessions
+  seatGuests(input: SeatGuestsInput): Promise<TableSession>
+  closeSession(sessionId: string): Promise<TableSession>
+  getActiveSessions(): Promise<TableSession[]>
+  getSessionHistory(tableId?: string): Promise<TableSession[]>
+
+  // Zones
+  getZones(): Promise<Zone[]>
+  createZone(data: Partial<Zone>): Promise<Zone>
+  updateZone(id: string, data: Partial<Zone>): Promise<Zone>
+  deleteZone(id: string): Promise<void>
+
+  // Summary
+  getSummary(): Promise<TablesSummary>
+}