@fayz-ai/plugin-orders 0.9.0 → 0.9.2

package/src/data/platform.ts

@@ -1,456 +0,0 @@
-import { createFayzClient, type FayzClientOptions, type FayzTableFilter } from '@fayz-ai/sdk'
-import type {
-  CreateOrderInput,
-  CreateOrderItemInput,
-  OrderKind,
-  OrderQuery,
-  OrdersSummary,
-  OrderStatus,
-  PaginatedResult,
-  RestaurantOrder,
-  RestaurantOrderItem,
-  UpdateOrderStatusInput,
-} from '../types'
-import type { OrdersDataProvider } from './types'
-
-export interface FayzOrdersProviderOptions extends FayzClientOptions {
-  projectId?: string
-  schema?: string
-  runtime?: boolean
-  ordersTable?: string
-  orderItemsTable?: string
-  /**
-   * Active tenant id (or a getter) used to scope reads and stamp writes on the
-   * orders table. When omitted, scoping is left to the runtime/RLS context.
-   * Only the orders table carries `tenant_id`; order_items scope via their
-   * parent order, so this never touches the order-items table.
-   */
-  tenantId?: string | (() => string | undefined | null)
-}
-
-interface OrderRow {
-  id: string
-  tenant_id?: string | null
-  reference_number?: string | null
-  kind?: OrderKind | null
-  status?: OrderStatus | null
-  party_id?: string | null
-  party_name?: string | null
-  assignee_id?: string | null
-  assignee_name?: string | null
-  location_id?: string | null
-  subtotal?: number | string | null
-  discount?: number | string | null
-  tax?: number | string | null
-  total?: number | string | null
-  currency?: string | null
-  notes?: string | null
-  tags?: string[] | null
-  source?: string | null
-  table_id?: string | null
-  table_name?: string | null
-  estimated_minutes?: number | null
-  metadata?: Record<string, unknown> | null
-  created_at?: string | null
-  updated_at?: string | null
-  completed_at?: string | null
-}
-
-interface OrderItemRow {
-  id: string
-  order_id?: string | null
-  product_id?: string | null
-  name?: string | null
-  description?: string | null
-  quantity?: number | string | null
-  unit_price?: number | string | null
-  discount?: number | string | null
-  total?: number | string | null
-  sort_order?: number | null
-  modifiers?: string | null
-  kitchen_notes?: string | null
-  metadata?: Record<string, unknown> | null
-  created_at?: string | null
-}
-
-const DEFAULT_ORDERS_TABLE = 'orders'
-const DEFAULT_ORDER_ITEMS_TABLE = 'order_items'
-const ACTIVE_STATUSES = new Set<OrderStatus>(['new', 'confirmed', 'preparing', 'ready', 'served', 'dispatched'])
-
-function nowIso(): string {
-  return new Date().toISOString()
-}
-
-function numberValue(value: number | string | null | undefined): number {
-  if (typeof value === 'number') return value
-  if (typeof value === 'string') return Number(value) || 0
-  return 0
-}
-
-function dateKey(value: string): string {
-  return value.slice(0, 10)
-}
-
-function referenceNumber(): string {
-  return `ORD-${Date.now().toString().slice(-6)}`
-}
-
-function itemToRow(item: CreateOrderItemInput, orderId: string, sortOrder: number): Record<string, unknown> {
-  const discount = item.discount ?? 0
-  return {
-    order_id: orderId,
-    product_id: item.productId ?? null,
-    name: item.name,
-    quantity: item.quantity,
-    unit_price: item.unitPrice,
-    discount,
-    total: item.quantity * item.unitPrice - discount,
-    sort_order: sortOrder,
-    modifiers: item.modifiers ?? null,
-    kitchen_notes: item.kitchenNotes ?? null,
-  }
-}
-
-function rowToItem(row: OrderItemRow): RestaurantOrderItem {
-  const quantity = numberValue(row.quantity)
-  const unitPrice = numberValue(row.unit_price)
-  const discount = numberValue(row.discount)
-  return {
-    id: row.id,
-    orderId: row.order_id ?? '',
-    productId: row.product_id ?? undefined,
-    name: row.name ?? 'Item',
-    description: row.description ?? undefined,
-    quantity,
-    unitPrice,
-    discount,
-    total: numberValue(row.total) || quantity * unitPrice - discount,
-    sortOrder: row.sort_order ?? 0,
-    modifiers: row.modifiers ?? undefined,
-    kitchenNotes: row.kitchen_notes ?? undefined,
-    metadata: row.metadata ?? {},
-    createdAt: row.created_at ?? nowIso(),
-  }
-}
-
-function rowToOrder(row: OrderRow, items: RestaurantOrderItem[] = []): RestaurantOrder {
-  const subtotal = numberValue(row.subtotal) || items.reduce((sum, item) => sum + item.total, 0)
-  const discount = numberValue(row.discount)
-  const tax = numberValue(row.tax)
-  return {
-    id: row.id,
-    referenceNumber: row.reference_number ?? row.id,
-    kind: row.kind ?? 'dine_in',
-    status: row.status ?? 'new',
-    partyId: row.party_id ?? undefined,
-    partyName: row.party_name ?? undefined,
-    assigneeId: row.assignee_id ?? undefined,
-    assigneeName: row.assignee_name ?? undefined,
-    locationId: row.location_id ?? undefined,
-    subtotal,
-    discount,
-    tax,
-    total: numberValue(row.total) || subtotal - discount + tax,
-    currency: row.currency ?? 'BRL',
-    notes: row.notes ?? undefined,
-    tags: row.tags ?? [],
-    source: row.source ?? 'pos',
-    tableId: row.table_id ?? undefined,
-    tableName: row.table_name ?? undefined,
-    estimatedMinutes: row.estimated_minutes ?? undefined,
-    items,
-    metadata: row.metadata ?? {},
-    tenantId: row.tenant_id ?? 'runtime-tenant',
-    createdAt: row.created_at ?? nowIso(),
-    updatedAt: row.updated_at ?? row.created_at ?? nowIso(),
-    completedAt: row.completed_at ?? undefined,
-  }
-}
-
-function orderPayload(input: CreateOrderInput): Record<string, unknown> {
-  const subtotal = input.items.reduce((sum, item) => sum + item.quantity * item.unitPrice - (item.discount ?? 0), 0)
-  return {
-    reference_number: referenceNumber(),
-    kind: input.kind,
-    status: 'new',
-    source: input.source ?? 'pos',
-    table_id: input.tableId ?? null,
-    party_id: input.partyId ?? null,
-    assignee_id: input.assigneeId ?? null,
-    notes: input.notes ?? null,
-    estimated_minutes: input.estimatedMinutes ?? null,
-    subtotal,
-    discount: 0,
-    tax: 0,
-    total: subtotal,
-    currency: 'BRL',
-    tags: [],
-  }
-}
-
-function updatePayload(data: Partial<RestaurantOrder>): Record<string, unknown> {
-  const payload: Record<string, unknown> = {}
-  if (data.referenceNumber !== undefined) payload.reference_number = data.referenceNumber
-  if (data.kind !== undefined) payload.kind = data.kind
-  if (data.status !== undefined) payload.status = data.status
-  if (data.partyId !== undefined) payload.party_id = data.partyId
-  if (data.partyName !== undefined) payload.party_name = data.partyName
-  if (data.assigneeId !== undefined) payload.assignee_id = data.assigneeId
-  if (data.assigneeName !== undefined) payload.assignee_name = data.assigneeName
-  if (data.locationId !== undefined) payload.location_id = data.locationId
-  if (data.subtotal !== undefined) payload.subtotal = data.subtotal
-  if (data.discount !== undefined) payload.discount = data.discount
-  if (data.tax !== undefined) payload.tax = data.tax
-  if (data.total !== undefined) payload.total = data.total
-  if (data.currency !== undefined) payload.currency = data.currency
-  if (data.notes !== undefined) payload.notes = data.notes
-  if (data.tags !== undefined) payload.tags = data.tags
-  if (data.source !== undefined) payload.source = data.source
-  if (data.tableId !== undefined) payload.table_id = data.tableId
-  if (data.tableName !== undefined) payload.table_name = data.tableName
-  if (data.estimatedMinutes !== undefined) payload.estimated_minutes = data.estimatedMinutes
-  if (data.metadata !== undefined) payload.metadata = data.metadata
-  if (data.completedAt !== undefined) payload.completed_at = data.completedAt
-  return payload
-}
-
-function filtersFromQuery(query: OrderQuery): FayzTableFilter[] {
-  const filters: FayzTableFilter[] = []
-  if (query.kind && !Array.isArray(query.kind)) filters.push({ column: 'kind', operator: 'eq', value: query.kind })
-  if (query.status && !Array.isArray(query.status)) filters.push({ column: 'status', operator: 'eq', value: query.status })
-  if (query.source) filters.push({ column: 'source', operator: 'eq', value: query.source })
-  if (query.tableId) filters.push({ column: 'table_id', operator: 'eq', value: query.tableId })
-  if (query.assigneeId) filters.push({ column: 'assignee_id', operator: 'eq', value: query.assigneeId })
-  return filters
-}
-
-function matchesClientQuery(order: RestaurantOrder, query: OrderQuery): boolean {
-  if (Array.isArray(query.kind) && !query.kind.includes(order.kind)) return false
-  if (Array.isArray(query.status) && !query.status.includes(order.status)) return false
-  if (query.dateRange) {
-    const created = dateKey(order.createdAt)
-    if (created < query.dateRange.from || created > query.dateRange.to) return false
-  }
-  if (query.search) {
-    const search = query.search.toLowerCase()
-    return order.referenceNumber.toLowerCase().includes(search)
-      || (order.partyName?.toLowerCase().includes(search) ?? false)
-      || (order.tableName?.toLowerCase().includes(search) ?? false)
-      || order.items.some((item) => item.name.toLowerCase().includes(search))
-  }
-  return true
-}
-
-function paginate<T>(items: T[], page?: number, pageSize?: number): PaginatedResult<T> {
-  const currentPage = page ?? 1
-  const limit = pageSize ?? 20
-  const start = (currentPage - 1) * limit
-  return { data: items.slice(start, start + limit), total: items.length }
-}
-
-function summarize(orders: RestaurantOrder[], dateRange?: { from: string; to: string }): OrdersSummary {
-  const today = dateKey(nowIso())
-  const from = dateRange?.from ?? today
-  const to = dateRange?.to ?? today
-  const inRange = orders.filter((order) => {
-    const created = dateKey(order.createdAt)
-    return created >= from && created <= to
-  })
-  const billable = inRange.filter((order) => order.status !== 'cancelled')
-  const revenue = billable.reduce((sum, order) => sum + order.total, 0)
-  const ordersByKind: Record<OrderKind, number> = { dine_in: 0, takeout: 0, delivery: 0 }
-  const ordersByStatus: Record<string, number> = {}
-  const top = new Map<string, { name: string; quantity: number; revenue: number }>()
-
-  for (const order of inRange) {
-    ordersByKind[order.kind] = (ordersByKind[order.kind] ?? 0) + 1
-    ordersByStatus[order.status] = (ordersByStatus[order.status] ?? 0) + 1
-    if (order.status === 'cancelled') continue
-    for (const item of order.items) {
-      const current = top.get(item.name) ?? { name: item.name, quantity: 0, revenue: 0 }
-      current.quantity += item.quantity
-      current.revenue += item.total
-      top.set(item.name, current)
-    }
-  }
-
-  return {
-    todayOrderCount: inRange.length,
-    todayRevenue: revenue,
-    averageTicket: billable.length > 0 ? revenue / billable.length : 0,
-    activeOrderCount: orders.filter((order) => ACTIVE_STATUSES.has(order.status)).length,
-    ordersByKind,
-    ordersByStatus,
-    topItems: [...top.values()].sort((a, b) => b.quantity - a.quantity).slice(0, 5),
-  }
-}
-
-export function createFayzOrdersProvider(options: FayzOrdersProviderOptions = {}): OrdersDataProvider {
-  const client = createFayzClient(options)
-  const ordersTable = options.ordersTable ?? DEFAULT_ORDERS_TABLE
-  const orderItemsTable = options.orderItemsTable ?? DEFAULT_ORDER_ITEMS_TABLE
-  const tableOptions = { projectId: options.projectId, 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 listItemRows(orderIds: string[]): Promise<OrderItemRow[]> {
-    if (orderIds.length === 0) return []
-    const rows: OrderItemRow[] = []
-    await Promise.all(orderIds.map(async (orderId) => {
-      const response = await client.data.listRows<OrderItemRow>({
-        ...tableOptions,
-        table: orderItemsTable,
-        filters: [{ column: 'order_id', operator: 'eq', value: orderId }],
-        sortColumn: 'sort_order',
-        sortDirection: 'asc',
-        limit: 200,
-      })
-      rows.push(...response.rows)
-    }))
-    return rows
-  }
-
-  async function hydrate(rows: OrderRow[]): Promise<RestaurantOrder[]> {
-    const itemRows = await listItemRows(rows.map((row) => row.id))
-    const byOrder = new Map<string, RestaurantOrderItem[]>()
-    for (const itemRow of itemRows) {
-      const item = rowToItem(itemRow)
-      const list = byOrder.get(item.orderId) ?? []
-      list.push(item)
-      byOrder.set(item.orderId, list)
-    }
-    return rows.map((row) => rowToOrder(row, byOrder.get(row.id) ?? []))
-  }
-
-  async function listOrders(query: OrderQuery = {}): Promise<RestaurantOrder[]> {
-    const response = await client.data.listRows<OrderRow>({
-      ...tableOptions,
-      table: ordersTable,
-      filters: withTenant(filtersFromQuery(query)),
-      sortColumn: 'created_at',
-      sortDirection: 'desc',
-      limit: 500,
-    })
-    return (await hydrate(response.rows)).filter((order) => matchesClientQuery(order, query))
-  }
-
-  async function getById(id: string): Promise<RestaurantOrder | null> {
-    const response = await client.data.listRows<OrderRow>({
-      ...tableOptions,
-      table: ordersTable,
-      filters: withTenant([{ column: 'id', operator: 'eq', value: id }]),
-      limit: 1,
-    })
-    return (await hydrate(response.rows))[0] ?? null
-  }
-
-  return {
-    async getOrders(query) {
-      const orders = await listOrders(query)
-      return paginate(orders, query.page, query.pageSize)
-    },
-
-    async getOrderById(id) {
-      return getById(id)
-    },
-
-    async createOrder(input) {
-      const tenantId = resolveTenant()
-      const orderRow = await client.data.createRow<OrderRow>({
-        ...tableOptions,
-        table: ordersTable,
-        row: tenantId ? { ...orderPayload(input), tenant_id: tenantId } : orderPayload(input),
-      })
-      await Promise.all(input.items.map((item, index) => client.data.createRow<OrderItemRow>({
-        ...tableOptions,
-        table: orderItemsTable,
-        row: itemToRow(item, orderRow.id, index),
-      })))
-      return (await getById(orderRow.id)) ?? rowToOrder(orderRow)
-    },
-
-    async updateOrderStatus(input: UpdateOrderStatusInput) {
-      const completedAt = input.status === 'completed' ? nowIso() : undefined
-      return this.updateOrder(input.orderId, { status: input.status, completedAt })
-    },
-
-    async updateOrder(id, data) {
-      const row = await client.data.updateRow<OrderRow>({
-        ...tableOptions,
-        table: ordersTable,
-        primaryKeys: { id },
-        row: updatePayload(data),
-      })
-      return (await getById(row.id)) ?? rowToOrder(row)
-    },
-
-    async cancelOrder(id, reason) {
-      const order = await getById(id)
-      await this.updateOrder(id, {
-        status: 'cancelled',
-        notes: reason ? `${order?.notes ? `${order.notes}\n` : ''}Cancelled: ${reason}` : order?.notes,
-      })
-    },
-
-    async addOrderItem(orderId, item) {
-      const order = await getById(orderId)
-      const row = await client.data.createRow<OrderItemRow>({
-        ...tableOptions,
-        table: orderItemsTable,
-        row: itemToRow(item, orderId, order?.items.length ?? 0),
-      })
-      const created = rowToItem(row)
-      const items = [...(order?.items ?? []), created]
-      await this.updateOrder(orderId, {
-        subtotal: items.reduce((sum, orderItem) => sum + orderItem.total, 0),
-        total: items.reduce((sum, orderItem) => sum + orderItem.total, 0) - (order?.discount ?? 0) + (order?.tax ?? 0),
-      })
-      return created
-    },
-
-    async removeOrderItem(itemId) {
-      const orders = await listOrders()
-      const order = orders.find((item) => item.items.some((orderItem) => orderItem.id === itemId))
-      await client.data.deleteRows({ ...tableOptions, table: orderItemsTable, rows: [{ id: itemId }] })
-      if (order) {
-        const items = order.items.filter((item) => item.id !== itemId)
-        const subtotal = items.reduce((sum, item) => sum + item.total, 0)
-        await this.updateOrder(order.id, { subtotal, total: subtotal - order.discount + order.tax })
-      }
-    },
-
-    async updateOrderItem(itemId, data) {
-      const row = await client.data.updateRow<OrderItemRow>({
-        ...tableOptions,
-        table: orderItemsTable,
-        primaryKeys: { id: itemId },
-        row: {
-          product_id: data.productId,
-          name: data.name,
-          description: data.description,
-          quantity: data.quantity,
-          unit_price: data.unitPrice,
-          discount: data.discount,
-          total: data.total,
-          sort_order: data.sortOrder,
-          modifiers: data.modifiers,
-          kitchen_notes: data.kitchenNotes,
-          metadata: data.metadata,
-        },
-      })
-      return rowToItem(row)
-    },
-
-    async getSummary(dateRange) {
-      return summarize(await listOrders({ dateRange }), dateRange)
-    },
-  }
-}

package/src/data/types.ts

@@ -1,23 +0,0 @@
-import type {
-  RestaurantOrder, RestaurantOrderItem,
-  CreateOrderInput, CreateOrderItemInput, UpdateOrderStatusInput,
-  OrderQuery, PaginatedResult, OrdersSummary,
-} from '../types'
-
-export interface OrdersDataProvider {
-  // Orders
-  getOrders(query: OrderQuery): Promise<PaginatedResult<RestaurantOrder>>
-  getOrderById(id: string): Promise<RestaurantOrder | null>
-  createOrder(input: CreateOrderInput): Promise<RestaurantOrder>
-  updateOrderStatus(input: UpdateOrderStatusInput): Promise<RestaurantOrder>
-  updateOrder(id: string, data: Partial<RestaurantOrder>): Promise<RestaurantOrder>
-  cancelOrder(id: string, reason?: string): Promise<void>
-
-  // Order Items
-  addOrderItem(orderId: string, item: CreateOrderItemInput): Promise<RestaurantOrderItem>
-  removeOrderItem(itemId: string): Promise<void>
-  updateOrderItem(itemId: string, data: Partial<RestaurantOrderItem>): Promise<RestaurantOrderItem>
-
-  // Summary
-  getSummary(dateRange?: { from: string; to: string }): Promise<OrdersSummary>
-}

package/src/index.ts

@@ -1,224 +0,0 @@
-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'],
-    // Orders/month quota. NOTE: order creation currently flows only through the
-    // store/AI-tool (createOrder) with no dedicated UI create handler, so no
-    // client-side guard is wired yet — the declaration keeps the cap countable.
-    declaredLimits: [
-      { key: 'orders_month', label: 'Orders / month', table: 'orders', kindFilter: 'order', period: 'month' },
-    ],
-    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,
-        limitKey: 'orders_month',
-        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/platform'
-export type { FayzOrdersProviderOptions } from './data/platform'
-export type { ResolvedOrdersConfig } from './OrdersContext'