@fayz-ai/plugin-agenda 0.9.0 → 0.10.0

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

@@ -1,183 +0,0 @@
-// Booking ↔ Google Calendar event mapping — the SINGLE SOURCE OF TRUTH.
-//
-// These helpers are pure and Deno-friendly (only `import type`, no runtime
-// node/react/https imports), so the Supabase edge function imports this exact
-// file via a relative path (`../../src/integrations/google-calendar/mapping.ts`)
-// instead of keeping a divergent mirror. `import type` is elided by the Deno /
-// esbuild bundler, so the plugin `types.ts`/`CalendarBooking` type imports never
-// become runtime dependencies of the function bundle.
-//
-// Two callers, two input shapes:
-//   • the SDK/UI works with the rich `CalendarBooking` (camelCase, joined) — see
-//     bookingToEvent / eventToBookingPatch;
-//   • the edge function + RPCs work with the raw `AppointmentRow` (snake_case DB
-//     columns) — see appointmentRowToEvent / eventToAppointmentPatch.
-// Field decisions (title, all-day, cancel) are made once, here.
-import type { CalendarBooking } from '../../types'
-import type { GCalEvent, AppointmentRow, CalendarChannel, CalendarChannelRow } from './types'
-
-export interface GCalEventInput {
-  summary: string
-  description?: string
-  // Timed events use dateTime; all-day events use date (YYYY-MM-DD).
-  start: { dateTime?: string; date?: string; timeZone?: string }
-  end: { dateTime?: string; date?: string; timeZone?: string }
-}
-
-/** Normalized time window read off a Google event, all-day aware. */
-export interface EventTimes {
-  startsAt: string
-  endsAt: string
-  allDay: boolean
-}
-
-// --- Booking (rich SDK shape) → event -------------------------------------
-
-/** Build the event title from the booking's services + client. */
-export function bookingSummary(b: Pick<CalendarBooking, 'services' | 'clientName'>): string {
-  const services = (b.services ?? []).map((s) => s.name).filter(Boolean).join(', ')
-  const who = b.clientName ?? ''
-  if (services && who) return `${services} — ${who}`
-  return services || who || 'Appointment'
-}
-
-/** Map a Fayz booking to a Google Calendar event input. Returns null when the booking has no end. */
-export function bookingToEvent(b: CalendarBooking, timeZone?: string): GCalEventInput | null {
-  if (!b.startsAt || !b.endsAt) return null
-  const notes = [b.notes, b.professionalName ? `Pro: ${b.professionalName}` : '', b.locationName ?? '']
-    .filter(Boolean).join('\n')
-  return {
-    summary: bookingSummary(b),
-    description: notes || undefined,
-    start: { dateTime: b.startsAt, timeZone },
-    end: { dateTime: b.endsAt, timeZone },
-  }
-}
-
-/** Map an inbound Google event change to a partial booking update (reschedule/cancel), all-day aware. */
-export function eventToBookingPatch(ev: GCalEvent): { startsAt?: string; endsAt?: string; status?: 'cancelled' } {
-  if (ev.status === 'cancelled') return { status: 'cancelled' }
-  const t = eventTimes(ev)
-  return { startsAt: t.startsAt, endsAt: t.endsAt }
-}
-
-// --- Appointment row (raw DB shape) → event -------------------------------
-
-/**
- * Build the event title from an appointments row's denormalized metadata.
- * The raw row has no joined services/client, so we read the names the app
- * stamps onto metadata (serviceNames, contactName/clientName).
- */
-export function appointmentRowSummary(row: AppointmentRow): string {
-  const m = row.metadata ?? {}
-  const services = (m.serviceNames as string) ?? ''
-  const who = (m.contactName as string) ?? (m.clientName as string) ?? ''
-  if (services && who) return `${services} — ${who}`
-  return services || who || 'Appointment'
-}
-
-/** Map a raw appointments row to a Google event input (outbound push from the edge function). */
-export function appointmentRowToEvent(row: AppointmentRow): GCalEventInput {
-  return {
-    summary: appointmentRowSummary(row),
-    description: row.notes ?? undefined,
-    start: { dateTime: row.starts_at },
-    end: { dateTime: row.ends_at ?? row.starts_at },
-  }
-}
-
-/**
- * Map an inbound Google event to a DB-friendly appointment patch (snake_case
- * times), all-day aware, cancellation included. Consumed by the edge function
- * when calling gcal_apply_event_patch.
- */
-export function eventToAppointmentPatch(ev: GCalEvent): {
-  starts_at?: string
-  ends_at?: string
-  summary?: string
-  allDay?: boolean
-  cancelled: boolean
-} {
-  if (ev.status === 'cancelled') return { cancelled: true }
-  const t = eventTimes(ev)
-  return { starts_at: t.startsAt, ends_at: t.endsAt, summary: ev.summary, allDay: t.allDay, cancelled: false }
-}
-
-// --- Shared time normalization (all-day aware) ----------------------------
-
-/**
- * Read a normalized {startsAt, endsAt, allDay} window off a Google event.
- * All-day events carry `start.date`/`end.date` (YYYY-MM-DD, end exclusive) and
- * no dateTime; timed events carry dateTime. Falls back start→end when one side
- * is missing so callers always get a usable pair.
- */
-export function eventTimes(ev: GCalEvent): EventTimes {
-  const allDay = !ev.start?.dateTime && !!ev.start?.date
-  const startsAt = ev.start?.dateTime ?? ev.start?.date ?? ''
-  const endsAt = ev.end?.dateTime ?? ev.end?.date ?? startsAt
-  return { startsAt, endsAt, allDay }
-}
-
-// --- Channel resolution (outbound destination priority) -------------------
-
-/** Convert a raw plg_calendar_channels row (snake_case) to the camelCase CalendarChannel. */
-export function channelRowToChannel(r: CalendarChannelRow): CalendarChannel {
-  return {
-    id: r.id,
-    integrationId: r.integration_id,
-    tenantId: r.tenant_id,
-    googleCalendarId: r.google_calendar_id,
-    summary: r.summary ?? null,
-    color: r.color ?? null,
-    direction: r.direction,
-    targetKind: r.target_kind ?? null,
-    targetId: r.target_id ?? null,
-    importMode: r.import_mode ?? 'appointment',
-    syncToken: r.sync_token ?? null,
-    channelId: r.channel_id ?? null,
-    resourceId: r.resource_id ?? null,
-    channelExpiresAt: r.channel_expires_at ?? null,
-    isActive: r.is_active ?? true,
-    createdAt: r.created_at ?? '',
-    updatedAt: r.updated_at ?? '',
-  }
-}
-
-export interface ChannelMatchInput {
-  assigneeId?: string | null
-  serviceIds?: string[]
-  locationId?: string | null
-}
-
-/**
- * Pick the outbound destination channel for a booking, by priority:
- *   1. a channel targeting the booking's assignee,
- *   2. else a channel targeting one of the booking's services,
- *   3. else a channel targeting the booking's location,
- *   4. else the whole-agenda channel (targetKind === null).
- * Only active outbound/bidirectional channels are eligible. Returns null when
- * nothing matches (caller falls back to the integration's default calendar).
- */
-export function resolveTargetChannel(
-  channels: CalendarChannel[],
-  booking: ChannelMatchInput,
-): CalendarChannel | null {
-  const eligible = channels.filter(
-    (c) => c.isActive && (c.direction === 'outbound' || c.direction === 'bidirectional'),
-  )
-  const serviceIds = booking.serviceIds ?? []
-
-  if (booking.assigneeId) {
-    const byAssignee = eligible.find((c) => c.targetKind === 'assignee' && c.targetId === booking.assigneeId)
-    if (byAssignee) return byAssignee
-  }
-  if (serviceIds.length) {
-    const byService = eligible.find((c) => c.targetKind === 'service' && !!c.targetId && serviceIds.includes(c.targetId))
-    if (byService) return byService
-  }
-  if (booking.locationId) {
-    const byLocation = eligible.find((c) => c.targetKind === 'location' && c.targetId === booking.locationId)
-    if (byLocation) return byLocation
-  }
-  return eligible.find((c) => c.targetKind === null) ?? null
-}

package/src/integrations/google-calendar/migrations/001_google_calendar.sql

@@ -1,97 +0,0 @@
--- ---------------------------------------------------------------------------
--- Google Calendar integration (bidirectional) — connection + audit + triggers
--- ---------------------------------------------------------------------------
--- Outbound (Fayz booking → Google event) fires from a trigger on public.appointments
--- via pg_net to the google-calendar-sync edge function (push_event). Inbound
--- (Google → booking) runs on a pg_cron schedule (pull_events) and/or a Google
--- watch-channel webhook. The booking↔event link is stored on
--- public.appointments.metadata.googleCalendarEventId (no schema change there).
-
--- Plugin-owned tables carry the platform `plg_<plugin>_` prefix (DATA-MODEL.md
--- Ring 1). Legacy pools provisioned under the old `calendar_*` names are migrated
--- by 003_plg_rename.sql; fresh installs are born with the prefixed names here.
-CREATE TABLE IF NOT EXISTS public.plg_calendar_integrations (
-  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
-  provider text NOT NULL DEFAULT 'google',
-  oauth_refresh_token text,
-  oauth_access_token text,
-  token_expires_at timestamptz,
-  calendar_id text NOT NULL DEFAULT 'primary',
-  -- Incremental pull cursor + Google watch channel bookkeeping.
-  sync_token text,
-  channel_id text,
-  channel_resource_id text,
-  channel_expires_at timestamptz,
-  active boolean NOT NULL DEFAULT true,
-  last_sync_at timestamptz,
-  created_at timestamptz NOT NULL DEFAULT now(),
-  updated_at timestamptz NOT NULL DEFAULT now(),
-  UNIQUE (tenant_id, provider)
-);
-ALTER TABLE public.plg_calendar_integrations ENABLE ROW LEVEL SECURITY;
-CREATE INDEX IF NOT EXISTS idx_plg_calendar_integrations_tenant ON public.plg_calendar_integrations(tenant_id);
-
-CREATE TABLE IF NOT EXISTS public.plg_calendar_sync_log (
-  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
-  direction text NOT NULL,                 -- inbound | outbound
-  trigger text,                            -- on-write | scheduled | webhook | manual
-  status text NOT NULL DEFAULT 'success',  -- success | partial | error
-  fetched integer NOT NULL DEFAULT 0,
-  written integer NOT NULL DEFAULT 0,
-  error text,
-  created_at timestamptz NOT NULL DEFAULT now()
-);
-ALTER TABLE public.plg_calendar_sync_log ENABLE ROW LEVEL SECURITY;
-
--- RLS: tenant isolation.
-DO $$
-DECLARE t text;
-BEGIN
-  FOR t IN SELECT unnest(ARRAY['plg_calendar_integrations','plg_calendar_sync_log'])
-  LOOP
-    EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON public.%I TO authenticated', t);
-    IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename=t AND policyname=t||'_rls') THEN
-      EXECUTE format('CREATE POLICY %I ON public.%I FOR ALL TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids())) WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()))', t||'_rls', t);
-    END IF;
-  END LOOP;
-END $$;
-
--- ---------------------------------------------------------------------------
--- Outbound trigger: booking change → edge function (push_event).
--- Requires pg_net + a configured function URL. Set once per project:
---   ALTER DATABASE postgres SET app.gcal_sync_url = 'https://<ref>.functions.supabase.co/google-calendar-sync';
---   ALTER DATABASE postgres SET app.gcal_service_key = '<service-role-key>';
--- Safe to skip in environments without pg_net — outbound also works via the
--- client-side withGoogleCalendarSync() decorator.
--- ---------------------------------------------------------------------------
-CREATE OR REPLACE FUNCTION public.fn_gcal_push_booking() RETURNS trigger
-LANGUAGE plpgsql SECURITY DEFINER AS $$
-DECLARE
-  url text := current_setting('app.gcal_sync_url', true);
-  key text := current_setting('app.gcal_service_key', true);
-  rec record := COALESCE(NEW, OLD);
-  op  text := lower(TG_OP);
-BEGIN
-  IF url IS NULL OR url = '' THEN RETURN COALESCE(NEW, OLD); END IF;
-  PERFORM net.http_post(
-    url := url,
-    headers := jsonb_build_object('Content-Type', 'application/json', 'Authorization', 'Bearer ' || COALESCE(key, '')),
-    body := jsonb_build_object('action', 'push_event', 'op', op, 'bookingId', rec.id, 'tenantId', rec.tenant_id)
-  );
-  RETURN COALESCE(NEW, OLD);
-END $$;
-
-DROP TRIGGER IF EXISTS trg_gcal_push ON public.appointments;
-CREATE TRIGGER trg_gcal_push
-  AFTER INSERT OR UPDATE OR DELETE ON public.appointments
-  FOR EACH ROW EXECUTE FUNCTION public.fn_gcal_push_booking();
-
--- Inbound schedule (optional): pull external changes every 10 minutes.
---   SELECT cron.schedule('gcal-pull', '*/10 * * * *', $$
---     SELECT net.http_post(
---       url := current_setting('app.gcal_sync_url'),
---       headers := jsonb_build_object('Content-Type','application/json','Authorization','Bearer '||current_setting('app.gcal_service_key')),
---       body := jsonb_build_object('action','pull_events'));
---   $$);