@fayz-ai/plugin-agenda 0.9.0 → 0.10.0

package/src/integrations/google-calendar/components/ChannelMappingList.tsx

@@ -1,329 +0,0 @@
-// De-para (mapping) list — one row per Google calendar.
-//
-// Reads the user's Google calendars (listGoogleCalendars) and this tenant's
-// existing channels (listChannels), joins them by google_calendar_id, and lets
-// the user, per calendar:
-//   • toggle sync on/off            → creates/updates the channel (is_active)
-//   • pick a direction              → Two-way / Import only / Export only / Off
-//   • pick a target                 → Whole agenda / Professional / Service / Location
-//   • pick an import mode           → Block / Appointment
-// Every change is persisted immediately via saveChannel (RLS upsert on
-// integration_id + google_calendar_id), snapshotting the calendar summary+color
-// onto the channel. Target ids come from real host lookups (useAgendaLookups);
-// if a lookup is empty for the tenant the row degrades to a raw uuid input.
-import React, { useCallback, useEffect, useState } from 'react'
-import { Loader2, AlertCircle, RefreshCw } from 'lucide-react'
-import {
-  Button,
-  Checkbox,
-  Badge,
-  Select,
-  SelectTrigger,
-  SelectValue,
-  SelectContent,
-  SelectItem,
-  toast,
-} from '@fayz-ai/ui'
-import type { GoogleCalendarProvider } from '../data/supabase'
-import type {
-  CalendarChannel,
-  ChannelDirection,
-  ChannelTargetKind,
-  ChannelImportMode,
-  GoogleCalendarListEntry,
-} from '../types'
-import { CalendarColorDot } from './CalendarColorDot'
-import { useAgendaLookups, optionsForKind } from './useAgendaLookups'
-
-const DIRECTION_LABELS: Record<ChannelDirection, string> = {
-  bidirectional: 'Two-way',
-  inbound: 'Import only',
-  outbound: 'Export only',
-  off: 'Off',
-}
-const IMPORT_MODE_LABELS: Record<ChannelImportMode, string> = {
-  block: 'Block',
-  appointment: 'Appointment',
-}
-// 'agenda' is the UI sentinel for the whole-agenda target (target_kind = null).
-const TARGET_KIND_LABELS: Record<'agenda' | 'assignee' | 'service' | 'location', string> = {
-  agenda: 'Whole agenda',
-  assignee: 'Professional',
-  service: 'Service',
-  location: 'Location',
-}
-const NO_TARGET = '__none__'
-
-/** Defaults for a freshly-enabled calendar (mirror the migration defaults). */
-function defaultChannel(): {
-  direction: ChannelDirection
-  targetKind: ChannelTargetKind
-  targetId: string | null
-  importMode: ChannelImportMode
-} {
-  return { direction: 'bidirectional', targetKind: null, targetId: null, importMode: 'block' }
-}
-
-export function ChannelMappingList({
-  provider,
-  onChannelsChange,
-}: {
-  provider: GoogleCalendarProvider
-  /** Bubble the current channels up so the parent can gate the import wizard. */
-  onChannelsChange?: (channels: CalendarChannel[]) => void
-}) {
-  const [calendars, setCalendars] = useState<GoogleCalendarListEntry[]>([])
-  const [byGcalId, setByGcalId] = useState<Record<string, CalendarChannel>>({})
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-  const [savingId, setSavingId] = useState<string | null>(null)
-
-  const { lookups, hasAny: hasLookups } = useAgendaLookups(true)
-
-  const load = useCallback(async () => {
-    setLoading(true)
-    setError(null)
-    try {
-      const [cals, channels] = await Promise.all([
-        provider.listGoogleCalendars(),
-        provider.listChannels(),
-      ])
-      setCalendars(cals)
-      const map: Record<string, CalendarChannel> = {}
-      for (const ch of channels) map[ch.googleCalendarId] = ch
-      setByGcalId(map)
-      onChannelsChange?.(channels)
-    } catch (e: any) {
-      setError(e?.message ?? 'Could not load Google calendars')
-    } finally {
-      setLoading(false)
-    }
-  }, [provider, onChannelsChange])
-
-  useEffect(() => {
-    void load()
-  }, [load])
-
-  /** Persist a patch for one calendar, then refresh channels (keeps ids correct). */
-  const persist = useCallback(
-    async (
-      cal: GoogleCalendarListEntry,
-      patch: {
-        direction?: ChannelDirection
-        targetKind?: ChannelTargetKind
-        targetId?: string | null
-        importMode?: ChannelImportMode
-        isActive?: boolean
-      },
-    ) => {
-      const existing = byGcalId[cal.id]
-      const base = existing ?? { ...defaultChannel(), isActive: true }
-      setSavingId(cal.id)
-      try {
-        await provider.saveChannel({
-          id: existing?.id,
-          googleCalendarId: cal.id,
-          summary: cal.summary,
-          color: cal.backgroundColor ?? null,
-          direction: patch.direction ?? base.direction,
-          targetKind: patch.targetKind !== undefined ? patch.targetKind : base.targetKind,
-          targetId: patch.targetId !== undefined ? patch.targetId : base.targetId ?? null,
-          importMode: patch.importMode ?? base.importMode,
-          isActive: patch.isActive !== undefined ? patch.isActive : base.isActive,
-        })
-        const channels = await provider.listChannels()
-        const map: Record<string, CalendarChannel> = {}
-        for (const ch of channels) map[ch.googleCalendarId] = ch
-        setByGcalId(map)
-        onChannelsChange?.(channels)
-      } catch (e: any) {
-        toast.error(e?.message ?? 'Could not save calendar mapping')
-      } finally {
-        setSavingId(null)
-      }
-    },
-    [byGcalId, provider, onChannelsChange],
-  )
-
-  if (loading) {
-    return (
-      <div className="py-6 text-center text-sm text-muted-foreground">
-        <Loader2 className="h-4 w-4 animate-spin inline" />
-      </div>
-    )
-  }
-
-  if (error) {
-    return (
-      <div className="rounded-md border border-warning/40 bg-warning-soft/40 px-3 py-3 text-sm">
-        <div className="flex items-center gap-2 text-warning-soft-foreground">
-          <AlertCircle className="h-4 w-4" /> {error}
-        </div>
-        <Button variant="outline" size="sm" className="mt-2" onClick={() => void load()}>
-          <RefreshCw className="h-3.5 w-3.5" /> Retry
-        </Button>
-      </div>
-    )
-  }
-
-  if (calendars.length === 0) {
-    return (
-      <p className="py-6 text-center text-sm text-muted-foreground">
-        No Google calendars found on this account.
-      </p>
-    )
-  }
-
-  return (
-    <div className="rounded-md border divide-y">
-      {calendars.map((cal) => {
-        const ch = byGcalId[cal.id]
-        const active = !!ch?.isActive
-        const saving = savingId === cal.id
-        const direction: ChannelDirection = ch?.direction ?? 'bidirectional'
-        const targetKind: ChannelTargetKind = ch?.targetKind ?? null
-        const importMode: ChannelImportMode = ch?.importMode ?? 'block'
-        // Import mode only matters when Google can write into the agenda.
-        const canImport = direction === 'inbound' || direction === 'bidirectional'
-        const kindOptions = optionsForKind(lookups, targetKind)
-
-        return (
-          <div key={cal.id} className="px-3 py-3 space-y-3">
-            <div className="flex items-center gap-2.5">
-              <Checkbox
-                checked={active}
-                disabled={saving}
-                onChange={(next) => void persist(cal, { isActive: next })}
-              />
-              <CalendarColorDot color={cal.backgroundColor} />
-              <span className="text-sm font-medium truncate">{cal.summary}</span>
-              {cal.primary && (
-                <Badge variant="outline" className="shrink-0">
-                  Primary
-                </Badge>
-              )}
-              {saving && <Loader2 className="ml-auto h-3.5 w-3.5 animate-spin text-muted-foreground" />}
-            </div>
-
-            {active && (
-              <div className="grid gap-2 pl-[26px] sm:grid-cols-2 lg:grid-cols-4">
-                {/* Direction */}
-                <label className="block">
-                  <span className="text-[11px] font-medium text-muted-foreground">Direction</span>
-                  <Select
-                    value={direction}
-                    onValueChange={(v) => void persist(cal, { direction: v as ChannelDirection })}
-                  >
-                    <SelectTrigger className="mt-1 h-8 text-sm">
-                      <SelectValue />
-                    </SelectTrigger>
-                    <SelectContent>
-                      {(Object.keys(DIRECTION_LABELS) as ChannelDirection[]).map((d) => (
-                        <SelectItem key={d} value={d}>
-                          {DIRECTION_LABELS[d]}
-                        </SelectItem>
-                      ))}
-                    </SelectContent>
-                  </Select>
-                </label>
-
-                {/* Target kind */}
-                <label className="block">
-                  <span className="text-[11px] font-medium text-muted-foreground">Target</span>
-                  <Select
-                    value={targetKind ?? 'agenda'}
-                    onValueChange={(v) =>
-                      void persist(cal, {
-                        targetKind: v === 'agenda' ? null : (v as ChannelTargetKind),
-                        // Reset the id whenever the kind changes.
-                        targetId: null,
-                      })
-                    }
-                  >
-                    <SelectTrigger className="mt-1 h-8 text-sm">
-                      <SelectValue />
-                    </SelectTrigger>
-                    <SelectContent>
-                      {(Object.keys(TARGET_KIND_LABELS) as Array<keyof typeof TARGET_KIND_LABELS>).map(
-                        (k) => (
-                          <SelectItem key={k} value={k}>
-                            {TARGET_KIND_LABELS[k]}
-                          </SelectItem>
-                        ),
-                      )}
-                    </SelectContent>
-                  </Select>
-                </label>
-
-                {/* Target id — real picker when we have lookups, uuid input otherwise */}
-                {targetKind && (
-                  <label className="block">
-                    <span className="text-[11px] font-medium text-muted-foreground">
-                      {TARGET_KIND_LABELS[targetKind]}
-                    </span>
-                    {kindOptions.length > 0 ? (
-                      <Select
-                        value={ch?.targetId ?? NO_TARGET}
-                        onValueChange={(v) =>
-                          void persist(cal, { targetId: v === NO_TARGET ? null : v })
-                        }
-                      >
-                        <SelectTrigger className="mt-1 h-8 text-sm">
-                          <SelectValue placeholder="Select…" />
-                        </SelectTrigger>
-                        <SelectContent>
-                          {kindOptions.map((o) => (
-                            <SelectItem key={o.id} value={o.id}>
-                              {o.name}
-                            </SelectItem>
-                          ))}
-                        </SelectContent>
-                      </Select>
-                    ) : (
-                      <input
-                        defaultValue={ch?.targetId ?? ''}
-                        placeholder="uuid"
-                        onBlur={(e) =>
-                          void persist(cal, { targetId: e.target.value.trim() || null })
-                        }
-                        className="w-full mt-1 h-8 rounded-input border border-input bg-card px-2 text-sm focus:outline-none focus:ring-2 focus:ring-ring"
-                      />
-                    )}
-                  </label>
-                )}
-
-                {/* Import mode — only when inbound */}
-                {canImport && (
-                  <label className="block">
-                    <span className="text-[11px] font-medium text-muted-foreground">Import as</span>
-                    <Select
-                      value={importMode}
-                      onValueChange={(v) => void persist(cal, { importMode: v as ChannelImportMode })}
-                    >
-                      <SelectTrigger className="mt-1 h-8 text-sm">
-                        <SelectValue />
-                      </SelectTrigger>
-                      <SelectContent>
-                        {(Object.keys(IMPORT_MODE_LABELS) as ChannelImportMode[]).map((m) => (
-                          <SelectItem key={m} value={m}>
-                            {IMPORT_MODE_LABELS[m]}
-                          </SelectItem>
-                        ))}
-                      </SelectContent>
-                    </Select>
-                  </label>
-                )}
-              </div>
-            )}
-          </div>
-        )
-      })}
-      {!hasLookups && (
-        <p className="px-3 py-2 text-[11px] text-muted-foreground">
-          No professional/service/location lookups available — target ids fall back to manual uuid
-          entry.
-        </p>
-      )}
-    </div>
-  )
-}

package/src/integrations/google-calendar/components/ImportEventsWizard.tsx

@@ -1,215 +0,0 @@
-// Import wizard — pull FUTURE Google events into the agenda as blocks/appointments.
-//
-// listExternalEvents() returns events on the active inbound channels that are not
-// yet linked to an appointment. The user ticks the ones to bring in and confirms;
-// importEvents() runs them through gcal_import_event (honouring each channel's
-// import_mode + target) and returns a per-item tally {imported, skipped, errors}.
-// Events show their source calendar as a colored badge and an "All-day" badge
-// when applicable; times are formatted pt-BR.
-import React, { useCallback, useEffect, useMemo, useState } from 'react'
-import { Loader2, CalendarPlus, CheckCircle2, AlertCircle, RefreshCw, X } from 'lucide-react'
-import { Button, Checkbox, Badge, toast } from '@fayz-ai/ui'
-import type { GoogleCalendarProvider } from '../data/supabase'
-import type { CalendarChannel, ExternalEventPreview, ImportEventsResult } from '../types'
-import { CalendarColorDot } from './CalendarColorDot'
-
-/** pt-BR datetime label, all-day aware (date only for all-day events). */
-function formatWhen(ev: ExternalEventPreview): string {
-  const start = new Date(ev.startsAt)
-  if (ev.allDay) {
-    return start.toLocaleDateString('pt-BR', { day: '2-digit', month: 'short', year: 'numeric' })
-  }
-  return start.toLocaleString('pt-BR', {
-    day: '2-digit',
-    month: 'short',
-    hour: '2-digit',
-    minute: '2-digit',
-  })
-}
-
-export function ImportEventsWizard({
-  provider,
-  channels,
-  onClose,
-  onImported,
-}: {
-  provider: GoogleCalendarProvider
-  /** Active channels — used to label each event with its source calendar + color. */
-  channels: CalendarChannel[]
-  onClose: () => void
-  /** Fired after a successful import so the parent can refresh status/history. */
-  onImported?: (result: ImportEventsResult) => void
-}) {
-  const [events, setEvents] = useState<ExternalEventPreview[]>([])
-  const [selected, setSelected] = useState<Set<string>>(new Set())
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-  const [importing, setImporting] = useState(false)
-  const [result, setResult] = useState<ImportEventsResult | null>(null)
-
-  const channelById = useMemo(() => {
-    const m: Record<string, CalendarChannel> = {}
-    for (const c of channels) m[c.id] = c
-    return m
-  }, [channels])
-
-  const load = useCallback(async () => {
-    setLoading(true)
-    setError(null)
-    setResult(null)
-    try {
-      const rows = await provider.listExternalEvents()
-      setEvents(rows)
-      setSelected(new Set(rows.map((r) => r.eventId)))
-    } catch (e: any) {
-      setError(e?.message ?? 'Could not load upcoming events')
-    } finally {
-      setLoading(false)
-    }
-  }, [provider])
-
-  useEffect(() => {
-    void load()
-  }, [load])
-
-  const toggle = (eventId: string) =>
-    setSelected((prev) => {
-      const next = new Set(prev)
-      if (next.has(eventId)) next.delete(eventId)
-      else next.add(eventId)
-      return next
-    })
-
-  const allSelected = events.length > 0 && selected.size === events.length
-  const toggleAll = () =>
-    setSelected(allSelected ? new Set() : new Set(events.map((e) => e.eventId)))
-
-  async function handleImport() {
-    const items = events
-      .filter((e) => selected.has(e.eventId))
-      .map((e) => ({ channelId: e.channelId, eventId: e.eventId }))
-    if (items.length === 0) return
-    setImporting(true)
-    try {
-      const res = await provider.importEvents(items)
-      setResult(res)
-      onImported?.(res)
-      toast.success(`Imported ${res.imported} · skipped ${res.skipped}`)
-      // Drop imported events from the list so the wizard reflects the new state.
-      await load()
-    } catch (e: any) {
-      toast.error(e?.message ?? 'Import failed')
-    } finally {
-      setImporting(false)
-    }
-  }
-
-  return (
-    <div className="rounded-md border bg-card">
-      <div className="flex items-center gap-2 border-b px-3 py-2">
-        <CalendarPlus className="h-4 w-4 text-muted-foreground" />
-        <h4 className="text-sm font-semibold">Import future events</h4>
-        <button
-          onClick={onClose}
-          className="ml-auto rounded p-1 text-muted-foreground hover:bg-muted/50"
-          aria-label="Close"
-        >
-          <X className="h-3.5 w-3.5" />
-        </button>
-      </div>
-
-      {loading ? (
-        <div className="py-8 text-center text-sm text-muted-foreground">
-          <Loader2 className="h-4 w-4 animate-spin inline" />
-        </div>
-      ) : error ? (
-        <div className="p-3">
-          <div className="flex items-center gap-2 text-sm text-warning-soft-foreground">
-            <AlertCircle className="h-4 w-4" /> {error}
-          </div>
-          <Button variant="outline" size="sm" className="mt-2" onClick={() => void load()}>
-            <RefreshCw className="h-3.5 w-3.5" /> Retry
-          </Button>
-        </div>
-      ) : events.length === 0 ? (
-        <div className="py-8 px-4 text-center space-y-1">
-          <p className="text-sm font-medium">You're all caught up</p>
-          <p className="text-xs text-muted-foreground">
-            No upcoming Google events left to import on your active calendars.
-          </p>
-          {result && (
-            <p className="text-xs text-success">
-              Imported {result.imported} · skipped {result.skipped}
-              {result.errors.length > 0 ? ` · ${result.errors.length} errors` : ''}
-            </p>
-          )}
-        </div>
-      ) : (
-        <>
-          <div className="flex items-center gap-2.5 border-b px-3 py-2">
-            <Checkbox checked={allSelected} onChange={toggleAll} />
-            <span className="text-xs text-muted-foreground">
-              {selected.size} of {events.length} selected
-            </span>
-          </div>
-          <div className="max-h-[320px] overflow-y-auto divide-y">
-            {events.map((ev) => {
-              const ch = channelById[ev.channelId]
-              return (
-                <label
-                  key={ev.eventId}
-                  className="flex items-start gap-2.5 px-3 py-2.5 cursor-pointer hover:bg-muted/30"
-                >
-                  <Checkbox
-                    checked={selected.has(ev.eventId)}
-                    onChange={() => toggle(ev.eventId)}
-                  />
-                  <div className="min-w-0 flex-1 space-y-1">
-                    <div className="flex items-center gap-2">
-                      <span className="text-sm font-medium truncate">
-                        {ev.summary || '(no title)'}
-                      </span>
-                      {ev.allDay && (
-                        <Badge variant="secondary" className="shrink-0">
-                          All-day
-                        </Badge>
-                      )}
-                    </div>
-                    <div className="flex items-center gap-2 text-xs text-muted-foreground">
-                      <span>{formatWhen(ev)}</span>
-                      <span className="inline-flex items-center gap-1">
-                        <CalendarColorDot color={ch?.color} />
-                        {ch?.summary ?? ev.calendarId}
-                      </span>
-                    </div>
-                  </div>
-                </label>
-              )
-            })}
-          </div>
-          <div className="flex items-center gap-2 border-t px-3 py-2">
-            {result && (
-              <span className="text-xs text-muted-foreground">
-                Last run: {result.imported} imported
-                {result.errors.length > 0 ? `, ${result.errors.length} errors` : ''}
-              </span>
-            )}
-            <Button
-              size="sm"
-              className="ml-auto"
-              disabled={importing || selected.size === 0}
-              onClick={handleImport}
-            >
-              {importing ? (
-                <Loader2 className="h-3.5 w-3.5 animate-spin" />
-              ) : (
-                <CheckCircle2 className="h-3.5 w-3.5" />
-              )}
-              Import {selected.size > 0 ? selected.size : ''}
-            </Button>
-          </div>
-        </>
-      )}
-    </div>
-  )
-}

package/src/integrations/google-calendar/components/useAgendaLookups.ts

@@ -1,100 +0,0 @@
-// Host-plugin lookups for the smart-sync de-para target picker.
-//
-// A channel can target one professional (assignee), one service, or one location
-// instead of the whole agenda. To offer real pickers (not raw uuid inputs) the
-// connector reuses plugin-agenda's own data providers — it lives inside the same
-// package, so these are in-process reads under the same RLS:
-//   • professionals + locations  → createSupabaseAgendaProvider()
-//   • services                    → createSupabasePublicBookingProvider() (v_public_services)
-// Everything is loaded once, lazily, and degrades to an empty list (the row then
-// falls back to a plain uuid input) if a lookup is unavailable for the tenant.
-import { useEffect, useState } from 'react'
-import { getActiveTenantId } from '@fayz-ai/core'
-import { createSupabaseAgendaProvider } from '../../../data'
-import { createSupabasePublicBookingProvider } from '../../../public/data.supabase'
-import type { ChannelTargetKind } from '../types'
-
-/** A pickable target option (assignee/service/location) — id + display name. */
-export interface LookupOption {
-  id: string
-  name: string
-}
-
-export interface AgendaLookups {
-  assignee: LookupOption[]
-  service: LookupOption[]
-  location: LookupOption[]
-}
-
-const EMPTY: AgendaLookups = { assignee: [], service: [], location: [] }
-
-export interface UseAgendaLookupsResult {
-  lookups: AgendaLookups
-  loading: boolean
-  /** True when at least one of the three lookups returned rows. */
-  hasAny: boolean
-}
-
-/**
- * Load professionals / services / locations for the target picker. Failures are
- * swallowed per-lookup (each falls back to an empty list) so a missing table or
- * a vertical without services never breaks the whole de-para screen.
- */
-export function useAgendaLookups(enabled: boolean): UseAgendaLookupsResult {
-  const [lookups, setLookups] = useState<AgendaLookups>(EMPTY)
-  const [loading, setLoading] = useState(false)
-
-  useEffect(() => {
-    if (!enabled) return
-    let cancelled = false
-    setLoading(true)
-    void (async () => {
-      const agenda = createSupabaseAgendaProvider()
-      const tenantId = getActiveTenantId()
-      const publicProvider = tenantId
-        ? createSupabasePublicBookingProvider({ tenantId })
-        : null
-
-      const [assignee, location, service] = await Promise.all([
-        agenda.getProfessionals().then(
-          (rows) => rows.map((p) => ({ id: p.id, name: p.name })),
-          () => [] as LookupOption[],
-        ),
-        (agenda.getLocations?.() ?? Promise.resolve([])).then(
-          (rows) => rows.map((l) => ({ id: l.id, name: l.name })),
-          () => [] as LookupOption[],
-        ),
-        (publicProvider?.getServices() ?? Promise.resolve([])).then(
-          (rows) => rows.map((s) => ({ id: s.id, name: s.name })),
-          () => [] as LookupOption[],
-        ),
-      ])
-
-      if (cancelled) return
-      setLookups({ assignee, service, location })
-      setLoading(false)
-    })()
-
-    return () => {
-      cancelled = true
-    }
-  }, [enabled])
-
-  const hasAny =
-    lookups.assignee.length > 0 ||
-    lookups.service.length > 0 ||
-    lookups.location.length > 0
-
-  return { lookups, loading, hasAny }
-}
-
-/** Options available for a given target kind (empty for whole-agenda / null). */
-export function optionsForKind(
-  lookups: AgendaLookups,
-  kind: ChannelTargetKind,
-): LookupOption[] {
-  if (kind === 'assignee') return lookups.assignee
-  if (kind === 'service') return lookups.service
-  if (kind === 'location') return lookups.location
-  return []
-}

package/src/integrations/google-calendar/connector.ts

@@ -1,20 +0,0 @@
-// Google Calendar connector descriptor (control-plane metadata).
-//
-// Declares the connector against the SDK integration spine so the platform can
-// reason about what it syncs. The actual data-plane verbs run in the
-// google-calendar-sync edge function; this is the typed contract + capabilities.
-import type { Connector } from '@fayz-ai/core'
-
-export const googleCalendarConnector: Connector = {
-  id: 'google-calendar',
-  provider: 'google',
-  pluginId: 'agenda',
-  authKind: 'oauth',
-  capabilities: [
-    {
-      entity: 'booking',
-      direction: 'bidirectional',
-      triggers: ['on-write', 'scheduled', 'webhook'],
-    },
-  ],
-}