@fayz-ai/plugin-agenda 0.8.1 → 0.8.4

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

@@ -1,17 +1,38 @@
-// Booking ↔ Google Calendar event mapping (pure helpers).
+// Booking ↔ Google Calendar event mapping — the SINGLE SOURCE OF TRUTH.
 //
-// Shared shape used both by the SDK (docs/tests) and mirrored by the edge
-// function. Keeping it pure makes the field decisions reviewable in one place.
+// 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 } from './types'
+import type { GCalEvent, AppointmentRow, CalendarChannel, CalendarChannelRow } from './types'
 
 export interface GCalEventInput {
   summary: string
   description?: string
-  start: { dateTime: string; timeZone?: string }
-  end: { dateTime: string; timeZone?: 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(', ')
@@ -33,11 +54,130 @@ export function bookingToEvent(b: CalendarBooking, timeZone?: string): GCalEvent
   }
 }
 
-/** Map an inbound Google event change to a partial booking update (reschedule/cancel). */
+/** 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 {
-    startsAt: ev.start?.dateTime,
-    endsAt: ev.end?.dateTime,
+    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

@@ -7,7 +7,10 @@
 -- watch-channel webhook. The booking↔event link is stored on
 -- public.appointments.metadata.googleCalendarEventId (no schema change there).
 
-CREATE TABLE IF NOT EXISTS public.calendar_integrations (
+-- 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',
@@ -26,10 +29,10 @@ CREATE TABLE IF NOT EXISTS public.calendar_integrations (
   updated_at timestamptz NOT NULL DEFAULT now(),
   UNIQUE (tenant_id, provider)
 );
-ALTER TABLE public.calendar_integrations ENABLE ROW LEVEL SECURITY;
-CREATE INDEX IF NOT EXISTS idx_calendar_integrations_tenant ON public.calendar_integrations(tenant_id);
+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.calendar_sync_log (
+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
@@ -40,13 +43,13 @@ CREATE TABLE IF NOT EXISTS public.calendar_sync_log (
   error text,
   created_at timestamptz NOT NULL DEFAULT now()
 );
-ALTER TABLE public.calendar_sync_log ENABLE ROW LEVEL SECURITY;
+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['calendar_integrations','calendar_sync_log'])
+  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