@fayz-ai/plugin-agenda 0.2.0 → 0.2.1

package/src/public/context.tsx

@@ -0,0 +1,43 @@
+import { createContext, useContext, type ReactNode } from 'react'
+import type { PaymentProvider } from '@fayz-ai/core'
+import type { AgendaDataProvider } from '../data/types'
+import type { PublicService, BookingWindow, PublicBookingLabels, WorkingHours, ResolvedPayment } from './types'
+
+/** Emitted when the customer's phone is verified / identity captured, for the
+ *  host to bridge to auth (booking stays decoupled — data-only, optional). */
+export type OnIdentityVerified = (identity: { name: string; phone: string; email?: string }) => void
+
+export interface PublicBookingContextValue {
+  provider: AgendaDataProvider
+  /** The professional/resource bookings are created against (POC: single professional). */
+  professionalId: string
+  professionalName: string
+  services: PublicService[]
+  /** Business opening hours, shown on the overview "Sobre" section. */
+  businessHours: WorkingHours
+  /** Payment step config, or null when the flow ends at confirmation. */
+  payment: ResolvedPayment | null
+  /** Injected charge provider (Pix). When absent, the payment step self-mocks. */
+  paymentProvider: PaymentProvider | null
+  /** Fired on phone-verify / details submit so the host can sign the user in. */
+  onIdentityVerified: OnIdentityVerified | null
+  window: BookingWindow
+  labels: PublicBookingLabels
+  /** Currency code for price formatting (e.g. 'BRL'). */
+  currency: string
+  locale: string
+}
+
+const PublicBookingContext = createContext<PublicBookingContextValue | null>(null)
+
+export function BookingProvider({ value, children }: { value: PublicBookingContextValue; children: ReactNode }) {
+  return <PublicBookingContext.Provider value={value}>{children}</PublicBookingContext.Provider>
+}
+
+export function useBooking(): PublicBookingContextValue {
+  const ctx = useContext(PublicBookingContext)
+  if (!ctx) {
+    throw new Error('[plugin-agenda] useBooking must be used within <BookingProvider>.')
+  }
+  return ctx
+}

package/src/public/createPublicBookingPlugin.ts

@@ -0,0 +1,155 @@
+import { createElement, type FC, type ReactNode } from 'react'
+import type { PluginManifest, PluginScope, VerticalId, PaymentProvider } from '@fayz-ai/core'
+import { createSafeDataProvider } from '@fayz-ai/core'
+import type { AgendaDataProvider } from '../data/types'
+import type { Professional, Schedule } from '../types'
+import { createMockAgendaProvider, type MockAgendaSeed } from '../data/mock'
+import { createSupabaseAgendaProvider } from '../data/supabase'
+import { BookingProvider, type PublicBookingContextValue, type OnIdentityVerified } from './context'
+import { BookingWidget } from './BookingWidget'
+import type { PublicService, BookingWindow, PublicBookingLabels, WorkingHours, PaymentConfig, ResolvedPayment } from './types'
+
+export interface PublicBookingOptions {
+  /** Mount path for the public booking route. Default '/agendar'. */
+  basePath?: string
+  /** The single professional/resource bookings target (POC). */
+  professional?: { id?: string; name?: string }
+  /** Bookable services shown in the widget. */
+  services: PublicService[]
+  /** Working hours used to seed the mock provider's availability. */
+  workingHours?: WorkingHours
+  /** Booking-window bounds for the date/slot picker. */
+  window?: Partial<BookingWindow>
+  labels?: Partial<PublicBookingLabels>
+  /** Adds a final Pagamento (Pix) step. Omit/disable to end the flow at confirmation. */
+  payment?: PaymentConfig
+  /** Charge provider (from a payments plugin) used by the Pagamento step. Optional. */
+  paymentProvider?: PaymentProvider
+  /** Host bridge: fired when the customer's phone is verified / details submitted. */
+  onIdentityVerified?: OnIdentityVerified
+  currency?: string
+  locale?: string
+  /** Inject a custom provider (real availability). Overrides the safe resolver. */
+  dataProvider?: AgendaDataProvider
+  /** Override the full mock seed (advanced). */
+  seed?: MockAgendaSeed
+  scope?: PluginScope
+  verticalId?: VerticalId
+}
+
+export interface PublicBookingPlugin {
+  manifest: PluginManifest
+  Provider: FC<{ children: ReactNode }>
+  dataProvider: AgendaDataProvider
+}
+
+const DEFAULT_LABELS: PublicBookingLabels = {
+  title: 'Agende sua consulta',
+  serviceStep: 'Escolha o serviço',
+  dateStep: 'Escolha a data',
+  contactStep: 'Seus dados',
+  confirmCta: 'Confirmar agendamento',
+  successTitle: 'Agendamento confirmado!',
+  successBody: 'Você receberá os detalhes em breve. Até logo!',
+}
+
+const DEFAULT_WINDOW: BookingWindow = { minAdvanceHours: 2, maxAdvanceDays: 21, slotInterval: 30 }
+
+const DEFAULT_HOURS: WorkingHours = { daysOfWeek: [1, 2, 3, 4, 5, 6], start: '09:00', end: '18:00' }
+
+let scheduleId = 0
+
+function buildSchedules(professionalId: string, hours: WorkingHours): Schedule[] {
+  return hours.daysOfWeek.map((day) => ({
+    id: `sched-${professionalId}-${day}-${scheduleId++}`,
+    tenantId: 'public',
+    kind: 'working_hours',
+    assigneeId: professionalId,
+    locationId: null,
+    dayOfWeek: day,
+    specificDate: null,
+    startsAt: hours.start,
+    endsAt: hours.end,
+    isActive: true,
+    metadata: {},
+  }))
+}
+
+export function createPublicBookingPlugin(options: PublicBookingOptions): PublicBookingPlugin {
+  const basePath = options.basePath ?? '/agendar'
+  const professionalId = options.professional?.id ?? 'dr-hiago'
+  const professionalName = options.professional?.name ?? 'Especialista'
+  const window: BookingWindow = { ...DEFAULT_WINDOW, ...options.window }
+  const labels: PublicBookingLabels = { ...DEFAULT_LABELS, ...options.labels }
+  const currency = options.currency ?? 'BRL'
+  const locale = options.locale ?? 'pt-BR'
+  const hours = options.workingHours ?? DEFAULT_HOURS
+  const payment: ResolvedPayment | null = options.payment?.enabled
+    ? {
+        reservationFeePercent: options.payment.reservationFeePercent ?? 100,
+        method: options.payment.method ?? 'pix',
+      }
+    : null
+
+  const professional: Professional = {
+    id: professionalId,
+    name: professionalName,
+    avatarUrl: null,
+    locationId: null,
+    locationName: null,
+    isActive: true,
+  }
+  const mockSeed: MockAgendaSeed = options.seed ?? {
+    professionals: [professional],
+    schedules: buildSchedules(professionalId, hours),
+    bookings: [],
+  }
+
+  const provider =
+    options.dataProvider ??
+    createSafeDataProvider(
+      () => createSupabaseAgendaProvider(),
+      () => createMockAgendaProvider({ seed: mockSeed }),
+    )
+
+  const value: PublicBookingContextValue = {
+    provider,
+    professionalId,
+    professionalName,
+    services: options.services,
+    businessHours: hours,
+    payment,
+    paymentProvider: options.paymentProvider ?? null,
+    onIdentityVerified: options.onIdentityVerified ?? null,
+    window,
+    labels,
+    currency,
+    locale,
+  }
+  const Provider: FC<{ children: ReactNode }> = ({ children }) =>
+    createElement(BookingProvider, { value, children })
+  Provider.displayName = 'PublicBookingProvider'
+
+  const BookingScreen: FC<unknown> = () =>
+    createElement('section', { className: 'py-16 bg-background' },
+      createElement('div', { className: 'container mx-auto px-6' },
+        createElement(BookingWidget)))
+  BookingScreen.displayName = 'BookingScreen'
+
+  const manifest: PluginManifest = {
+    id: 'booking',
+    name: 'Agendamento',
+    icon: 'CalendarCheck',
+    version: '0.1.0',
+    scope: options.scope ?? 'universal',
+    verticalId: options.verticalId,
+    scaffolds: ['website', 'landing_page'],
+    defaultEnabled: true,
+    dependencies: [],
+    navigation: [],
+    routes: [{ path: basePath, component: BookingScreen, guard: 'public' }],
+    widgets: [],
+  }
+
+  return { manifest, Provider, dataProvider: provider }
+}

package/src/public/hooks.ts

@@ -0,0 +1,117 @@
+import { useEffect, useState } from 'react'
+import { useBooking } from './context'
+import type { PublicService, ContactInfo } from './types'
+import type { TimeSlot } from '../types'
+
+/** The configured bookable services (from context; POC-static, ERP-driven later). */
+export function useServices(): PublicService[] {
+  return useBooking().services
+}
+
+export interface UseAvailableSlotsResult {
+  slots: TimeSlot[]
+  loading: boolean
+  error: Error | null
+}
+
+/**
+ * Available time slots for a service on a given date. Delegates to
+ * provider.getAvailableSlots — mock now, real availability later, same call.
+ */
+export function useAvailableSlots(params: { serviceId: string | null; date: string | null }): UseAvailableSlotsResult {
+  const { provider, professionalId, services, window } = useBooking()
+  const [slots, setSlots] = useState<TimeSlot[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  const { serviceId, date } = params
+  const service = services.find((s) => s.id === serviceId)
+  const durationMinutes = service?.durationMinutes ?? 0
+
+  useEffect(() => {
+    let active = true
+    if (!serviceId || !date || !durationMinutes) {
+      setSlots([])
+      return
+    }
+    setLoading(true)
+    provider
+      .getAvailableSlots({ assigneeId: professionalId, date, durationMinutes, slotInterval: window.slotInterval })
+      .then((result) => {
+        if (!active) return
+        setSlots(result)
+        setError(null)
+      })
+      .catch((err) => {
+        if (!active) return
+        setError(err instanceof Error ? err : new Error(String(err)))
+      })
+      .finally(() => {
+        if (active) setLoading(false)
+      })
+    return () => {
+      active = false
+    }
+  }, [provider, professionalId, serviceId, date, durationMinutes, window.slotInterval])
+
+  return { slots, loading, error }
+}
+
+export interface CreatePublicBookingInput {
+  serviceId: string
+  /** ISO datetime of the chosen slot start. */
+  startsAt: string
+  contact: ContactInfo
+}
+
+export interface UseCreateBookingResult {
+  submit: (input: CreatePublicBookingInput) => Promise<void>
+  submitting: boolean
+  error: Error | null
+  done: boolean
+}
+
+/** Create a booking via the provider. POC: mock append; real persistence later. */
+export function useCreateBooking(): UseCreateBookingResult {
+  const { provider, professionalId, services } = useBooking()
+  const [submitting, setSubmitting] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+  const [done, setDone] = useState(false)
+
+  async function submit(input: CreatePublicBookingInput): Promise<void> {
+    const service = services.find((s) => s.id === input.serviceId)
+    if (!service) throw new Error('Serviço inválido')
+    setSubmitting(true)
+    setError(null)
+    try {
+      await provider.createBooking({
+        kind: 'appointment',
+        // POC: the customer is captured as the booking title; a real flow would
+        // upsert a client/person record and pass its id here.
+        clientId: 'public-guest',
+        professionalId,
+        startsAt: input.startsAt,
+        title: input.contact.name,
+        notes: [input.contact.phone, input.contact.email, input.contact.notes].filter(Boolean).join(' · ') || undefined,
+        services: [
+          {
+            serviceId: service.id,
+            name: service.name,
+            durationMinutes: service.durationMinutes,
+            price: service.price,
+            assigneeId: professionalId,
+          },
+        ],
+      })
+      setDone(true)
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err))
+      setError(e)
+      throw e
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  return { submit, submitting, error, done }
+}

package/src/public/index.ts

@@ -0,0 +1,15 @@
+// ---------------------------------------------------------------------------
+// @fayz-ai/plugin-agenda/public — customer-facing booking surface.
+//
+// Separate entry from the admin plugin so a website host imports only the lean
+// booking widget + data seam (no @fayz-ai/saas / calendar admin graph).
+// ---------------------------------------------------------------------------
+
+export { createPublicBookingPlugin } from './createPublicBookingPlugin'
+export type { PublicBookingOptions, PublicBookingPlugin } from './createPublicBookingPlugin'
+export { BookingWidget } from './BookingWidget'
+export { BookingProvider, useBooking } from './context'
+export type { PublicBookingContextValue } from './context'
+export { useServices, useAvailableSlots, useCreateBooking } from './hooks'
+export type { UseAvailableSlotsResult, UseCreateBookingResult, CreatePublicBookingInput } from './hooks'
+export type { PublicService, ContactInfo, BookingWindow, PublicBookingLabels, WorkingHours } from './types'

package/src/public/types.ts

@@ -0,0 +1,63 @@
+// ---------------------------------------------------------------------------
+// Public (customer-facing) booking types. This surface is deliberately decoupled
+// from the admin calendar: it depends only on the AgendaDataProvider interface,
+// so mock slots today and real availability (Supabase RPC / ERP / Google
+// Calendar) later are a provider swap with no widget change.
+// ---------------------------------------------------------------------------
+
+export interface PublicService {
+  id: string
+  name: string
+  durationMinutes: number
+  price: number
+  description?: string
+}
+
+export interface ContactInfo {
+  name: string
+  email?: string
+  phone?: string
+  notes?: string
+}
+
+export interface WorkingHours {
+  /** 0=Sun … 6=Sat. */
+  daysOfWeek: number[]
+  /** 'HH:MM' */
+  start: string
+  /** 'HH:MM' */
+  end: string
+}
+
+export interface BookingWindow {
+  /** Earliest lead time before a slot can be booked. */
+  minAdvanceHours: number
+  /** How many days ahead the date picker offers. */
+  maxAdvanceDays: number
+  /** Slot granularity in minutes. */
+  slotInterval: number
+}
+
+export interface PaymentConfig {
+  /** Show a Pagamento step as the final stage of the flow. */
+  enabled?: boolean
+  /** % of the service price charged up-front as a reservation fee (default 100). */
+  reservationFeePercent?: number
+  /** Payment method (POC ships 'pix'). */
+  method?: 'pix'
+}
+
+export interface ResolvedPayment {
+  reservationFeePercent: number
+  method: 'pix'
+}
+
+export interface PublicBookingLabels {
+  title: string
+  serviceStep: string
+  dateStep: string
+  contactStep: string
+  confirmCta: string
+  successTitle: string
+  successBody: string
+}