@soulbatical/tetra-core 0.1.39 → 0.1.41

package/dist/shared/planner/PlannerService.js

@@ -0,0 +1,860 @@
+/**
+ * PlannerService — Core scheduling logic
+ *
+ * Handles:
+ * - Availability CRUD (multiple blocks per day)
+ * - Appointment CRUD with conflict detection
+ * - Vacation-aware slot computation
+ * - Team availability aggregation
+ * - Scheduler settings management
+ *
+ * Usage:
+ * ```typescript
+ * import { PlannerService } from '@soulbatical/tetra-core';
+ *
+ * const planner = new PlannerService(config);
+ * const slots = await planner.getAvailableSlots(db, ownerId, '2026-03-20');
+ * ```
+ */
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('planner:service');
+// ─── Time Helpers ───────────────────────────────────────────
+export function timeToMinutes(time) {
+    const parts = time.split(':');
+    return parseInt(parts[0], 10) * 60 + parseInt(parts[1], 10);
+}
+export function minutesToTime(minutes) {
+    const hh = String(Math.floor(minutes / 60)).padStart(2, '0');
+    const mm = String(minutes % 60).padStart(2, '0');
+    return `${hh}:${mm}`;
+}
+/**
+ * Compute bookable time slots from availability windows, minus existing appointments.
+ * Pure function — no DB access.
+ */
+export function computeAvailableSlots(availabilitySlots, existingAppointments, date, slotDurationMinutes = 60) {
+    const bookableSlots = [];
+    for (const slot of availabilitySlots) {
+        if (!slot.is_available)
+            continue;
+        const slotStartMinutes = timeToMinutes(slot.start_time);
+        const slotEndMinutes = timeToMinutes(slot.end_time);
+        let cursor = slotStartMinutes;
+        while (cursor + slotDurationMinutes <= slotEndMinutes) {
+            const candidateStart = cursor;
+            const candidateEnd = cursor + slotDurationMinutes;
+            const isBlocked = existingAppointments.some((appt) => {
+                const apptDate = appt.start_time.substring(0, 10);
+                if (apptDate !== date)
+                    return false;
+                const apptStartMinutes = timeToMinutes(appt.start_time.substring(11, 16));
+                const apptEndMinutes = timeToMinutes(appt.end_time.substring(11, 16));
+                return candidateStart < apptEndMinutes && candidateEnd > apptStartMinutes;
+            });
+            if (!isBlocked) {
+                bookableSlots.push({
+                    startTime: minutesToTime(candidateStart),
+                    endTime: minutesToTime(candidateEnd),
+                });
+            }
+            cursor += slotDurationMinutes;
+        }
+    }
+    return bookableSlots;
+}
+// ─── Row Transformers ───────────────────────────────────────
+function transformAppointment(row, config) {
+    const parentTable = config.parentResource?.table;
+    return {
+        id: row.id,
+        organizationId: row.organization_id,
+        parentId: row.parent_id,
+        organizerId: row.organizer_id,
+        title: row.title,
+        description: row.description,
+        startTime: row.start_time,
+        endTime: row.end_time,
+        location: row.location,
+        type: row.type,
+        status: row.status,
+        attendeeIds: row.attendee_ids || [],
+        googleCalendarEventId: row.google_calendar_event_id,
+        outlookEventId: row.outlook_event_id,
+        reminderSentAt: row.reminder_sent_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        organizer: row.organizer_name !== undefined
+            ? { id: row.organizer_id, name: row.organizer_name, email: row.organizer_email }
+            : (row.organizer ? { id: row.organizer_id, name: row.organizer?.name, email: row.organizer?.email } : null),
+        parent: row.parent_title !== undefined
+            ? { id: row.parent_id, title: row.parent_title }
+            : (row.parent ? { id: row.parent_id, title: row.parent?.title } : null),
+    };
+}
+// ─── Service Class ──────────────────────────────────────────
+export class PlannerService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get ownerRole() {
+        return this.config.ownerRole;
+    }
+    get ownerTable() {
+        return this.config.ownerTable || 'users_public';
+    }
+    get timezone() {
+        return this.config.timezone || 'Europe/Amsterdam';
+    }
+    get appointmentTypes() {
+        return this.config.appointmentTypes || ['online', 'phone', 'in_person'];
+    }
+    get appointmentStatuses() {
+        return this.config.appointmentStatuses || ['scheduled', 'completed', 'cancelled'];
+    }
+    // ─── Availability ───────────────────────────────────────────
+    /**
+     * Get an owner's recurring availability slots.
+     */
+    async getAvailability(db, ownerId) {
+        const { data, error } = await db
+            .from('planner_availability_slots')
+            .select('*')
+            .eq('owner_id', ownerId)
+            .order('day_of_week', { ascending: true })
+            .order('start_time', { ascending: true });
+        if (error) {
+            logger.error({ error, ownerId }, 'Failed to get availability');
+            throw new Error('Failed to retrieve availability');
+        }
+        return (data || []).map((row) => ({
+            id: row.id,
+            organizationId: row.organization_id,
+            ownerId: row.owner_id,
+            dayOfWeek: row.day_of_week,
+            startTime: row.start_time,
+            endTime: row.end_time,
+            isAvailable: row.is_available,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    /**
+     * Replace all availability slots for an owner.
+     */
+    async setAvailability(db, ownerId, organizationId, slots) {
+        // Validate
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            if (slot.dayOfWeek < 0 || slot.dayOfWeek > 6) {
+                throw new Error(`Slot ${i}: dayOfWeek must be 0-6`);
+            }
+            if (!slot.startTime || !slot.endTime) {
+                throw new Error(`Slot ${i}: startTime and endTime are required`);
+            }
+            if (timeToMinutes(slot.startTime) >= timeToMinutes(slot.endTime)) {
+                throw new Error(`Slot ${i}: endTime must be after startTime`);
+            }
+        }
+        // Delete existing
+        const { error: deleteError } = await db
+            .from('planner_availability_slots')
+            .delete()
+            .eq('owner_id', ownerId);
+        if (deleteError) {
+            logger.error({ error: deleteError, ownerId }, 'Failed to clear availability');
+            throw new Error('Failed to update availability');
+        }
+        if (slots.length === 0)
+            return [];
+        // Insert new
+        const insertRows = slots.map((slot) => ({
+            organization_id: organizationId,
+            owner_id: ownerId,
+            day_of_week: slot.dayOfWeek,
+            start_time: slot.startTime,
+            end_time: slot.endTime,
+            is_available: slot.isAvailable !== undefined ? slot.isAvailable : true,
+        }));
+        const { data, error: insertError } = await db
+            .from('planner_availability_slots')
+            .insert(insertRows)
+            .select();
+        if (insertError) {
+            logger.error({ error: insertError, ownerId }, 'Failed to insert availability');
+            throw new Error('Failed to save availability');
+        }
+        logger.info({ ownerId, slotCount: slots.length }, 'Availability updated');
+        return data || [];
+    }
+    // ─── Vacations ──────────────────────────────────────────────
+    /**
+     * Check if a date falls within any vacation for an owner.
+     */
+    async isOnVacation(db, ownerId, date) {
+        const { data, error } = await db
+            .from('planner_vacations')
+            .select('id')
+            .eq('owner_id', ownerId)
+            .lte('start_date', date)
+            .gte('end_date', date)
+            .limit(1);
+        if (error) {
+            logger.error({ error, ownerId, date }, 'Failed to check vacation');
+            return false;
+        }
+        return (data || []).length > 0;
+    }
+    /**
+     * Get all vacations for an owner.
+     */
+    async getVacations(db, ownerId) {
+        const { data, error } = await db
+            .from('planner_vacations')
+            .select('*')
+            .eq('owner_id', ownerId)
+            .order('start_date', { ascending: true });
+        if (error) {
+            logger.error({ error, ownerId }, 'Failed to get vacations');
+            throw new Error('Failed to retrieve vacations');
+        }
+        return (data || []).map((row) => ({
+            id: row.id,
+            organizationId: row.organization_id,
+            ownerId: row.owner_id,
+            startDate: row.start_date,
+            endDate: row.end_date,
+            description: row.description,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    /**
+     * Create a vacation period.
+     */
+    async createVacation(db, ownerId, organizationId, startDate, endDate, description) {
+        if (startDate > endDate) {
+            throw new Error('endDate must be on or after startDate');
+        }
+        const { data, error } = await db
+            .from('planner_vacations')
+            .insert({
+            organization_id: organizationId,
+            owner_id: ownerId,
+            start_date: startDate,
+            end_date: endDate,
+            description: description || null,
+        })
+            .select()
+            .single();
+        if (error) {
+            logger.error({ error, ownerId }, 'Failed to create vacation');
+            throw new Error('Failed to create vacation');
+        }
+        logger.info({ ownerId, startDate, endDate }, 'Vacation created');
+        return data;
+    }
+    /**
+     * Delete a vacation.
+     */
+    async deleteVacation(db, vacationId) {
+        const { error } = await db
+            .from('planner_vacations')
+            .delete()
+            .eq('id', vacationId);
+        if (error) {
+            logger.error({ error, vacationId }, 'Failed to delete vacation');
+            throw new Error('Failed to delete vacation');
+        }
+        logger.info({ vacationId }, 'Vacation deleted');
+    }
+    // ─── Scheduler Settings ─────────────────────────────────────
+    /**
+     * Get scheduler settings for an owner.
+     */
+    async getSettings(db, ownerId) {
+        const { data, error } = await db
+            .from('planner_scheduler_settings')
+            .select('*')
+            .eq('owner_id', ownerId)
+            .maybeSingle();
+        if (error) {
+            logger.error({ error, ownerId }, 'Failed to get scheduler settings');
+            throw new Error('Failed to retrieve settings');
+        }
+        const defaults = this.config.defaults || {};
+        if (!data) {
+            return {
+                eventName: 'Session',
+                zoomLink: null,
+                description: null,
+                sessionDurationMinutes: defaults.sessionDurationMinutes ?? 60,
+                maxDaysAhead: defaults.maxDaysAhead ?? 14,
+                minLeadTimeHours: defaults.minLeadTimeHours ?? 24,
+                timeIncrementMinutes: defaults.timeIncrementMinutes ?? 15,
+            };
+        }
+        return {
+            eventName: data.event_name ?? 'Session',
+            zoomLink: data.zoom_link ?? null,
+            description: data.description ?? null,
+            sessionDurationMinutes: data.session_duration_minutes ?? defaults.sessionDurationMinutes ?? 60,
+            maxDaysAhead: data.max_days_ahead ?? defaults.maxDaysAhead ?? 14,
+            minLeadTimeHours: data.min_lead_time_hours ?? defaults.minLeadTimeHours ?? 24,
+            timeIncrementMinutes: data.time_increment_minutes ?? defaults.timeIncrementMinutes ?? 15,
+        };
+    }
+    /**
+     * Upsert scheduler settings for an owner.
+     */
+    async updateSettings(db, ownerId, organizationId, settings) {
+        const row = {
+            owner_id: ownerId,
+            organization_id: organizationId,
+            updated_at: new Date().toISOString(),
+        };
+        if (settings.eventName !== undefined)
+            row.event_name = settings.eventName;
+        if (settings.zoomLink !== undefined)
+            row.zoom_link = settings.zoomLink;
+        if (settings.description !== undefined)
+            row.description = settings.description;
+        if (settings.sessionDurationMinutes !== undefined)
+            row.session_duration_minutes = settings.sessionDurationMinutes;
+        if (settings.maxDaysAhead !== undefined)
+            row.max_days_ahead = settings.maxDaysAhead;
+        if (settings.minLeadTimeHours !== undefined)
+            row.min_lead_time_hours = settings.minLeadTimeHours;
+        if (settings.timeIncrementMinutes !== undefined)
+            row.time_increment_minutes = settings.timeIncrementMinutes;
+        const { data, error } = await db
+            .from('planner_scheduler_settings')
+            .upsert(row, { onConflict: 'owner_id' })
+            .select()
+            .single();
+        if (error) {
+            logger.error({ error, ownerId }, 'Failed to update scheduler settings');
+            throw new Error('Failed to save settings');
+        }
+        logger.info({ ownerId }, 'Scheduler settings updated');
+        return data;
+    }
+    // ─── Available Slots ────────────────────────────────────────
+    /**
+     * Compute available booking slots for a specific date.
+     * Checks: availability, vacations, existing appointments, booking window, lead time.
+     */
+    async getAvailableSlots(db, ownerId, date) {
+        const parsedDate = new Date(date + 'T00:00:00Z');
+        if (isNaN(parsedDate.getTime())) {
+            throw new Error('Invalid date');
+        }
+        const dayOfWeek = parsedDate.getUTCDay();
+        // 1. Check vacation
+        const onVacation = await this.isOnVacation(db, ownerId, date);
+        const settings = await this.getSettings(db, ownerId);
+        if (onVacation) {
+            return { date, dayOfWeek, ownerId, slots: [], sessionDurationMinutes: settings.sessionDurationMinutes };
+        }
+        // 2. Check booking window
+        const now = new Date();
+        const requestedDate = new Date(date + 'T23:59:59Z');
+        const maxDate = new Date(now);
+        maxDate.setDate(maxDate.getDate() + settings.maxDaysAhead);
+        if (requestedDate > maxDate) {
+            return { date, dayOfWeek, ownerId, slots: [], sessionDurationMinutes: settings.sessionDurationMinutes };
+        }
+        // 3. Get availability for this day of week
+        const { data: availabilitySlots, error: availError } = await db
+            .from('planner_availability_slots')
+            .select('*')
+            .eq('owner_id', ownerId)
+            .eq('day_of_week', dayOfWeek)
+            .eq('is_available', true)
+            .order('start_time', { ascending: true });
+        if (availError || !availabilitySlots?.length) {
+            return { date, dayOfWeek, ownerId, slots: [], sessionDurationMinutes: settings.sessionDurationMinutes };
+        }
+        // 4. Get existing appointments for this date
+        const existingAppointments = await this.getExistingAppointments(db, ownerId, date);
+        // 5. Compute slots
+        const allSlots = computeAvailableSlots(availabilitySlots, existingAppointments, date, settings.sessionDurationMinutes);
+        // 6. Filter by minimum lead time
+        const minBookingTime = new Date(now.getTime() + settings.minLeadTimeHours * 60 * 60 * 1000);
+        const slots = allSlots.filter((slot) => {
+            const slotStart = new Date(`${date}T${slot.startTime}:00Z`);
+            return slotStart >= minBookingTime;
+        });
+        return { date, dayOfWeek, ownerId, slots, sessionDurationMinutes: settings.sessionDurationMinutes };
+    }
+    /**
+     * Get existing scheduled appointments for an owner on a date.
+     */
+    async getExistingAppointments(db, ownerId, date) {
+        const dayStart = `${date}T00:00:00Z`;
+        const dayEnd = `${date}T23:59:59Z`;
+        const appointments = [];
+        // Appointments where owner is organizer
+        const { data: organizerAppts } = await db
+            .from('planner_appointments')
+            .select('start_time, end_time')
+            .eq('organizer_id', ownerId)
+            .eq('status', 'scheduled')
+            .gte('start_time', dayStart)
+            .lte('start_time', dayEnd);
+        if (organizerAppts) {
+            appointments.push(...organizerAppts);
+        }
+        // If parent resource is configured, also check appointments through parent records
+        if (this.config.parentResource) {
+            const { table, foreignKey } = this.config.parentResource;
+            const { data: ownerParents } = await db
+                .from(table)
+                .select('id')
+                .or(`${foreignKey}.eq.${ownerId}`);
+            const parentIds = (ownerParents || []).map((p) => p.id);
+            if (parentIds.length > 0) {
+                const { data: parentAppts } = await db
+                    .from('planner_appointments')
+                    .select('start_time, end_time')
+                    .in('parent_id', parentIds)
+                    .eq('status', 'scheduled')
+                    .gte('start_time', dayStart)
+                    .lte('start_time', dayEnd);
+                if (parentAppts) {
+                    // Deduplicate
+                    const existingTimes = new Set(appointments.map((a) => `${a.start_time}|${a.end_time}`));
+                    for (const appt of parentAppts) {
+                        const key = `${appt.start_time}|${appt.end_time}`;
+                        if (!existingTimes.has(key)) {
+                            appointments.push(appt);
+                            existingTimes.add(key);
+                        }
+                    }
+                }
+            }
+        }
+        return appointments;
+    }
+    // ─── Team Availability ──────────────────────────────────────
+    /**
+     * Get availability for all owners in an organization for a specific date.
+     */
+    async getTeamAvailability(db, organizationId, date) {
+        const parsedDate = new Date(date + 'T00:00:00Z');
+        if (isNaN(parsedDate.getTime())) {
+            throw new Error('Invalid date');
+        }
+        const dayOfWeek = parsedDate.getUTCDay();
+        const ownerTable = this.ownerTable;
+        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
+        // Get all owners (coaches/consultants) in this organization
+        const { data: owners, error: ownersError } = await db
+            .from(ownerTable)
+            .select('id, name, avatar_url')
+            .eq(orgColumn, organizationId)
+            .eq('role', this.ownerRole);
+        if (ownersError || !owners?.length) {
+            return { date, dayOfWeek, owners: [] };
+        }
+        // For each owner, compute their availability
+        const ownerResults = await Promise.all(owners.map(async (owner) => {
+            try {
+                const dayAvailability = await this.getAvailableSlots(db, owner.id, date);
+                const onVacation = await this.isOnVacation(db, owner.id, date);
+                return {
+                    id: owner.id,
+                    name: owner.name,
+                    avatarUrl: owner.avatar_url,
+                    slots: dayAvailability.slots,
+                    vacationDay: onVacation,
+                };
+            }
+            catch {
+                return {
+                    id: owner.id,
+                    name: owner.name,
+                    avatarUrl: owner.avatar_url,
+                    slots: [],
+                    vacationDay: false,
+                };
+            }
+        }));
+        return { date, dayOfWeek, owners: ownerResults };
+    }
+    // ─── Appointments ───────────────────────────────────────────
+    /**
+     * List all appointments for a user (as organizer or via parent resources).
+     */
+    async listAppointments(db, userId, options) {
+        let query = db
+            .from('planner_appointments')
+            .select('*')
+            .order('start_time', { ascending: true });
+        // Build OR filter: organizer OR involved via parent resource
+        if (this.config.parentResource) {
+            const { table, foreignKey, clientKey } = this.config.parentResource;
+            // Find parent IDs where user is owner or client
+            const orParts = [`${foreignKey}.eq.${userId}`];
+            if (clientKey)
+                orParts.push(`${clientKey}.eq.${userId}`);
+            const { data: userParents } = await db
+                .from(table)
+                .select('id')
+                .or(orParts.join(','));
+            const parentIds = (userParents || []).map((p) => p.id);
+            if (parentIds.length > 0) {
+                query = query.or(`organizer_id.eq.${userId},parent_id.in.(${parentIds.join(',')})`);
+            }
+            else {
+                query = query.eq('organizer_id', userId);
+            }
+        }
+        else {
+            query = query.eq('organizer_id', userId);
+        }
+        if (options?.status === 'all') {
+            // No filter
+        }
+        else if (options?.status && this.appointmentStatuses.includes(options.status)) {
+            query = query.eq('status', options.status);
+        }
+        else {
+            query = query.neq('status', 'cancelled');
+        }
+        const { data, error } = await query;
+        if (error) {
+            logger.error({ error, userId }, 'Failed to list appointments');
+            throw new Error('Failed to retrieve appointments');
+        }
+        return (data || []).map((row) => transformAppointment(row, this.config));
+    }
+    /**
+     * Create an appointment.
+     */
+    async createAppointment(db, organizerId, organizationId, input) {
+        const start = new Date(input.startTime);
+        const end = new Date(input.endTime);
+        if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+            throw new Error('Invalid date format for startTime or endTime');
+        }
+        if (end <= start) {
+            throw new Error('endTime must be after startTime');
+        }
+        const appointmentType = input.type || 'online';
+        if (!this.appointmentTypes.includes(appointmentType)) {
+            throw new Error(`Invalid type. Must be one of: ${this.appointmentTypes.join(', ')}`);
+        }
+        const insertData = {
+            organization_id: organizationId,
+            organizer_id: organizerId,
+            title: input.title,
+            start_time: start.toISOString(),
+            end_time: end.toISOString(),
+            type: appointmentType,
+            status: 'scheduled',
+        };
+        if (input.parentId)
+            insertData.parent_id = input.parentId;
+        if (input.description !== undefined)
+            insertData.description = input.description;
+        if (input.location !== undefined)
+            insertData.location = input.location;
+        if (Array.isArray(input.attendeeIds))
+            insertData.attendee_ids = input.attendeeIds;
+        const { data, error } = await db
+            .from('planner_appointments')
+            .insert(insertData)
+            .select()
+            .single();
+        if (error) {
+            logger.error({ error, organizerId }, 'Failed to create appointment');
+            if (error.code === '23503') {
+                throw new Error('Invalid parent resource ID');
+            }
+            throw new Error('Failed to create appointment');
+        }
+        logger.info({ appointmentId: data.id, organizerId }, 'Appointment created');
+        const appointment = transformAppointment(data, this.config);
+        // Fire callback (non-blocking)
+        if (this.config.onAppointmentCreated) {
+            const ctx = { ownerId: organizerId, organizationId };
+            this.config.onAppointmentCreated(appointment, ctx).catch((err) => {
+                logger.error({ error: err, appointmentId: data.id }, 'onAppointmentCreated callback failed');
+            });
+        }
+        return appointment;
+    }
+    /**
+     * Update an appointment.
+     */
+    async updateAppointment(db, appointmentId, updates) {
+        const updateData = {
+            updated_at: new Date().toISOString(),
+        };
+        if (updates.title !== undefined)
+            updateData.title = updates.title;
+        if (updates.description !== undefined)
+            updateData.description = updates.description;
+        if (updates.location !== undefined)
+            updateData.location = updates.location;
+        if (updates.startTime !== undefined) {
+            const start = new Date(updates.startTime);
+            if (isNaN(start.getTime()))
+                throw new Error('Invalid startTime');
+            updateData.start_time = start.toISOString();
+        }
+        if (updates.endTime !== undefined) {
+            const end = new Date(updates.endTime);
+            if (isNaN(end.getTime()))
+                throw new Error('Invalid endTime');
+            updateData.end_time = end.toISOString();
+        }
+        if (updates.type !== undefined) {
+            if (!this.appointmentTypes.includes(updates.type)) {
+                throw new Error(`Invalid type. Must be one of: ${this.appointmentTypes.join(', ')}`);
+            }
+            updateData.type = updates.type;
+        }
+        if (updateData.start_time && updateData.end_time) {
+            if (new Date(updateData.end_time) <= new Date(updateData.start_time)) {
+                throw new Error('endTime must be after startTime');
+            }
+        }
+        const { data, error } = await db
+            .from('planner_appointments')
+            .update(updateData)
+            .eq('id', appointmentId)
+            .select()
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116')
+                throw new Error('Appointment not found');
+            logger.error({ error, appointmentId }, 'Failed to update appointment');
+            throw new Error('Failed to update appointment');
+        }
+        logger.info({ appointmentId }, 'Appointment updated');
+        return transformAppointment(data, this.config);
+    }
+    /**
+     * Cancel an appointment (soft delete).
+     */
+    async cancelAppointment(db, appointmentId, organizationId) {
+        const { data, error } = await db
+            .from('planner_appointments')
+            .update({ status: 'cancelled', updated_at: new Date().toISOString() })
+            .eq('id', appointmentId)
+            .neq('status', 'cancelled')
+            .select()
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116')
+                throw new Error('Appointment not found');
+            logger.error({ error, appointmentId }, 'Failed to cancel appointment');
+            throw new Error('Failed to cancel appointment');
+        }
+        logger.info({ appointmentId }, 'Appointment cancelled');
+        const appointment = transformAppointment(data, this.config);
+        if (this.config.onAppointmentCancelled) {
+            const ctx = { ownerId: data.organizer_id, organizationId };
+            this.config.onAppointmentCancelled(appointment, ctx).catch((err) => {
+                logger.error({ error: err, appointmentId }, 'onAppointmentCancelled callback failed');
+            });
+        }
+        return appointment;
+    }
+    /**
+     * Complete an appointment.
+     */
+    async completeAppointment(db, appointmentId, organizationId) {
+        const { data, error } = await db
+            .from('planner_appointments')
+            .update({ status: 'completed', updated_at: new Date().toISOString() })
+            .eq('id', appointmentId)
+            .eq('status', 'scheduled')
+            .select()
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116')
+                throw new Error('Appointment not found');
+            logger.error({ error, appointmentId }, 'Failed to complete appointment');
+            throw new Error('Failed to complete appointment');
+        }
+        logger.info({ appointmentId }, 'Appointment completed');
+        const appointment = transformAppointment(data, this.config);
+        if (this.config.onAppointmentCompleted) {
+            const ctx = { ownerId: data.organizer_id, organizationId };
+            this.config.onAppointmentCompleted(appointment, ctx).catch((err) => {
+                logger.error({ error: err, appointmentId }, 'onAppointmentCompleted callback failed');
+            });
+        }
+        return appointment;
+    }
+    // ─── Public Booking ─────────────────────────────────────────
+    /**
+     * Get public scheduler page data (no auth).
+     */
+    async getPublicSchedulerData(db, ownerId) {
+        const ownerTable = this.ownerTable;
+        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
+        const { data: ownerRow, error: ownerError } = await db
+            .from(ownerTable)
+            .select('*')
+            .eq('id', ownerId)
+            .single();
+        if (ownerError || !ownerRow)
+            return null;
+        const owner = ownerRow;
+        const orgId = owner[orgColumn];
+        const { data: org } = await db
+            .from('organizations')
+            .select('name')
+            .eq('id', orgId)
+            .single();
+        const settings = await this.getSettings(db, ownerId);
+        const { data: availability } = await db
+            .from('planner_availability_slots')
+            .select('day_of_week')
+            .eq('owner_id', ownerId)
+            .eq('is_available', true);
+        const availableDays = [...new Set((availability || []).map((s) => s.day_of_week))];
+        return {
+            owner: { id: owner.id, name: owner.name, avatarUrl: owner.avatar_url },
+            organization: { name: org?.name ?? null },
+            settings,
+            availableDays,
+        };
+    }
+    /**
+     * Book a slot via public booking (no auth).
+     */
+    async publicBook(db, ownerId, input) {
+        // Validate
+        if (!input.name || !input.email || !input.date || !input.startTime || !input.endTime) {
+            throw new Error('name, email, date, startTime, and endTime are required');
+        }
+        const parsedDate = new Date(input.date + 'T00:00:00Z');
+        if (isNaN(parsedDate.getTime()))
+            throw new Error('Invalid date');
+        if (timeToMinutes(input.startTime) >= timeToMinutes(input.endTime)) {
+            throw new Error('endTime must be after startTime');
+        }
+        // Check vacation
+        const onVacation = await this.isOnVacation(db, ownerId, input.date);
+        if (onVacation) {
+            throw new Error('Owner is on vacation on this date');
+        }
+        // Check availability
+        const dayOfWeek = parsedDate.getUTCDay();
+        const { data: availSlots } = await db
+            .from('planner_availability_slots')
+            .select('*')
+            .eq('owner_id', ownerId)
+            .eq('day_of_week', dayOfWeek)
+            .eq('is_available', true);
+        const requestedStart = timeToMinutes(input.startTime);
+        const requestedEnd = timeToMinutes(input.endTime);
+        const isWithin = (availSlots || []).some((slot) => {
+            const slotStart = timeToMinutes(slot.start_time);
+            const slotEnd = timeToMinutes(slot.end_time);
+            return requestedStart >= slotStart && requestedEnd <= slotEnd;
+        });
+        if (!isWithin) {
+            throw new Error('Requested time is outside availability');
+        }
+        // Check conflicts
+        const existingAppts = await this.getExistingAppointments(db, ownerId, input.date);
+        const hasConflict = existingAppts.some((appt) => {
+            const apptStart = timeToMinutes(appt.start_time.substring(11, 16));
+            const apptEnd = timeToMinutes(appt.end_time.substring(11, 16));
+            return requestedStart < apptEnd && requestedEnd > apptStart;
+        });
+        if (hasConflict) {
+            throw new Error('Time slot is no longer available');
+        }
+        // Get owner info
+        const ownerTable = this.ownerTable;
+        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
+        const { data: ownerData } = await db
+            .from(ownerTable)
+            .select(`id, name, ${orgColumn}`)
+            .eq('id', ownerId)
+            .single();
+        if (!ownerData)
+            throw new Error('Owner not found');
+        const organizationId = ownerData[orgColumn];
+        const settings = await this.getSettings(db, ownerId);
+        const zoomLink = settings.zoomLink;
+        // Auto-link to parent resource if booker email matches
+        let parentId = null;
+        if (this.config.parentResource) {
+            const { table, foreignKey, clientKey } = this.config.parentResource;
+            if (clientKey) {
+                const { data: bookerUser } = await db
+                    .from(ownerTable)
+                    .select('id')
+                    .eq('email', input.email.toLowerCase().trim())
+                    .eq(orgColumn, organizationId)
+                    .maybeSingle();
+                if (bookerUser) {
+                    const { data: matchingParent } = await db
+                        .from(table)
+                        .select('id')
+                        .or(`${foreignKey}.eq.${ownerId}`)
+                        .eq(clientKey, bookerUser.id)
+                        .eq('status', 'active')
+                        .limit(1)
+                        .maybeSingle();
+                    if (matchingParent) {
+                        parentId = matchingParent.id;
+                        logger.info({ parentId, bookerEmail: input.email, ownerId }, 'Auto-linked public booking to parent');
+                    }
+                }
+            }
+        }
+        const startISO = `${input.date}T${input.startTime.length === 5 ? input.startTime + ':00' : input.startTime}Z`;
+        const endISO = `${input.date}T${input.endTime.length === 5 ? input.endTime + ':00' : input.endTime}Z`;
+        const { data: appointment, error: insertError } = await db
+            .from('planner_appointments')
+            .insert({
+            organization_id: organizationId,
+            parent_id: parentId,
+            organizer_id: ownerId,
+            title: `${settings.eventName} - ${input.name}`,
+            description: [
+                'Booked via public scheduler',
+                `Name: ${input.name}`,
+                `Email: ${input.email}`,
+                input.notes ? `Notes: ${input.notes}` : null,
+                zoomLink ? `Zoom: ${zoomLink}` : null,
+            ].filter(Boolean).join('\n'),
+            start_time: startISO,
+            end_time: endISO,
+            type: 'online',
+            status: 'scheduled',
+        })
+            .select()
+            .single();
+        if (insertError) {
+            logger.error({ error: insertError, ownerId, name: input.name }, 'Failed to create public booking');
+            throw new Error('Failed to create appointment');
+        }
+        logger.info({
+            appointmentId: appointment.id,
+            ownerId,
+            visitorName: input.name,
+            visitorEmail: input.email,
+        }, 'Public booking created');
+        const record = transformAppointment(appointment, this.config);
+        // Fire callback
+        if (this.config.onPublicBooking) {
+            const ctx = { ownerId, organizationId };
+            const visitor = { name: input.name, email: input.email, notes: input.notes };
+            this.config.onPublicBooking(record, visitor, ctx).catch((err) => {
+                logger.error({ error: err, appointmentId: appointment.id }, 'onPublicBooking callback failed');
+            });
+        }
+        return record;
+    }
+}
+//# sourceMappingURL=PlannerService.js.map