@porulle/plugin-appointments 0.1.0

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBtB,CAAC;AAIJ,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,CAAC;AAIJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS1B,CAAC;AAIJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS5B,CAAC;AAIJ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW/B,CAAC;AAIJ,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAC;AAIH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBlB,CAAC;AAIJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1B,CAAC"}

package/dist/schema.js

@@ -0,0 +1,128 @@
+import { boolean, integer, jsonb, pgTable, text, timestamp, uuid, index, uniqueIndex } from "@porulle/core/drizzle";
+// ─── Service Types ──────────────────────────────────────────────────────────
+export const serviceTypes = pgTable("appointment_service_types", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    name: text("name").notNull(),
+    slug: text("slug").notNull(),
+    description: text("description"),
+    durationMinutes: integer("duration_minutes").notNull().default(30),
+    priceCents: integer("price_cents").notNull().default(0),
+    currency: text("currency").notNull().default("USD"),
+    mode: text("mode").notNull().default("in_person"), // in_person | online | hybrid
+    bufferBeforeMinutes: integer("buffer_before_minutes").notNull().default(0),
+    bufferAfterMinutes: integer("buffer_after_minutes").notNull().default(0),
+    maxAdvanceDays: integer("max_advance_days").notNull().default(60),
+    minNoticeMins: integer("min_notice_mins").notNull().default(60),
+    isActive: boolean("is_active").notNull().default(true),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgSlugUnique: uniqueIndex("apt_service_types_org_slug_unique").on(table.organizationId, table.slug),
+    orgIdx: index("idx_apt_service_types_org").on(table.organizationId),
+    slugIdx: index("idx_apt_service_types_slug").on(table.slug),
+    activeIdx: index("idx_apt_service_types_active").on(table.isActive),
+}));
+// ─── Providers ──────────────────────────────────────────────────────────────
+export const providers = pgTable("appointment_providers", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    userId: text("user_id"), // Better Auth user ID (nullable for admin-created providers)
+    name: text("name").notNull(),
+    bio: text("bio"),
+    email: text("email"),
+    phone: text("phone"),
+    timezone: text("timezone").notNull().default("UTC"),
+    isActive: boolean("is_active").notNull().default(true),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_apt_providers_org").on(table.organizationId),
+    activeIdx: index("idx_apt_providers_active").on(table.isActive),
+}));
+// ─── Provider–ServiceType Link ──────────────────────────────────────────────
+export const providerServices = pgTable("appointment_provider_services", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    providerId: uuid("provider_id").notNull(),
+    serviceTypeId: uuid("service_type_id").notNull(),
+    customDurationMinutes: integer("custom_duration_minutes"),
+    customPriceCents: integer("custom_price_cents"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    providerServiceIdx: uniqueIndex("idx_provider_service").on(table.providerId, table.serviceTypeId),
+}));
+// ─── Weekly Availability ────────────────────────────────────────────────────
+export const weeklyAvailability = pgTable("appointment_weekly_availability", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    providerId: uuid("provider_id").notNull(),
+    dayOfWeek: integer("day_of_week").notNull(), // 0 = Sunday, 6 = Saturday
+    startTime: text("start_time").notNull(), // "09:00" (HH:mm in provider's timezone)
+    endTime: text("end_time").notNull(), // "17:00"
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    providerDayIdx: index("idx_weekly_provider_day").on(table.providerId, table.dayOfWeek),
+}));
+// ─── Availability Overrides (date-level) ────────────────────────────────────
+export const availabilityOverrides = pgTable("appointment_availability_overrides", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    providerId: uuid("provider_id").notNull(),
+    date: text("date").notNull(), // "2026-03-25" (YYYY-MM-DD)
+    isAvailable: boolean("is_available").notNull().default(true),
+    startTime: text("start_time"), // null if isAvailable = false (day off)
+    endTime: text("end_time"),
+    reason: text("reason"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    providerDateIdx: uniqueIndex("idx_override_provider_date").on(table.providerId, table.date),
+}));
+// ─── Breaks ─────────────────────────────────────────────────────────────────
+export const breaks = pgTable("appointment_breaks", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    providerId: uuid("provider_id").notNull(),
+    dayOfWeek: integer("day_of_week"), // null = every day
+    startTime: text("start_time").notNull(), // "12:00"
+    endTime: text("end_time").notNull(), // "13:00"
+    label: text("label"), // "Lunch"
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+});
+// ─── Bookings ───────────────────────────────────────────────────────────────
+export const bookings = pgTable("appointment_bookings", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    providerId: uuid("provider_id").notNull(),
+    serviceTypeId: uuid("service_type_id").notNull(),
+    customerId: text("customer_id").notNull(),
+    customerName: text("customer_name").notNull(),
+    customerEmail: text("customer_email").notNull(),
+    customerPhone: text("customer_phone"),
+    startTime: timestamp("start_time", { withTimezone: true }).notNull(),
+    endTime: timestamp("end_time", { withTimezone: true }).notNull(),
+    status: text("status").notNull().default("provisional"),
+    // provisional → confirmed → completed | cancelled | no_show
+    paymentMethod: text("payment_method").notNull(), // "card" | "cash" | "invoice"
+    notes: text("notes"),
+    cancellationReason: text("cancellation_reason"),
+    rescheduledFromId: uuid("rescheduled_from_id"),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    providerTimeIdx: index("idx_apt_bookings_provider_time").on(table.providerId, table.startTime),
+    customerIdx: index("idx_apt_bookings_customer").on(table.customerId),
+    statusIdx: index("idx_apt_bookings_status").on(table.status),
+    startTimeIdx: index("idx_apt_bookings_start_time").on(table.startTime),
+}));
+// ─── Booking Payments ───────────────────────────────────────────────────────
+export const bookingPayments = pgTable("appointment_booking_payments", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    bookingId: uuid("booking_id").notNull().unique(),
+    amountCents: integer("amount_cents").notNull(),
+    currency: text("currency").notNull(),
+    status: text("status").notNull().default("pending"), // pending | paid | refunded | failed
+    paymentIntentId: text("payment_intent_id"),
+    paidAt: timestamp("paid_at", { withTimezone: true }),
+    refundedAt: timestamp("refunded_at", { withTimezone: true }),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+});

package/dist/services/booking-service.d.ts

@@ -0,0 +1,156 @@
+import { bookings } from "../schema.js";
+import { SlotService } from "./slot-service.js";
+import type { Db, BookingStatus } from "../types.js";
+import type { JobsAdapter } from "@porulle/core";
+interface BookingInput {
+    providerId: string;
+    serviceTypeId: string;
+    customerId: string;
+    customerName: string;
+    customerEmail: string;
+    customerPhone?: string | undefined;
+    startTime: Date;
+    paymentMethod: "card" | "cash" | "invoice";
+    notes?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+interface PaymentAdapterLike {
+    createPaymentIntent(params: {
+        amount: number;
+        currency: string;
+        orderId: string;
+        customerId?: string | undefined;
+        metadata?: Record<string, string> | undefined;
+    }): Promise<{
+        ok: true;
+        value: {
+            id: string;
+            clientSecret?: string | null;
+        };
+    } | {
+        ok: false;
+        error: {
+            message: string;
+        };
+    }>;
+    refundPayment(paymentId: string, amount: number, reason?: string): Promise<{
+        ok: boolean;
+    }>;
+}
+export declare class BookingService {
+    private db;
+    private slotService;
+    private paymentAdapter?;
+    private jobs?;
+    private transitions;
+    constructor(db: Db, slotService: SlotService, paymentAdapter?: PaymentAdapterLike | undefined, jobs?: JobsAdapter | undefined);
+    private providerOrganizationId;
+    create(input: BookingInput, txDb?: Db): Promise<{
+        ok: true;
+        booking: typeof bookings.$inferSelect;
+        paymentIntent?: {
+            id: string;
+            clientSecret?: string | null;
+        } | undefined;
+    } | {
+        ok: false;
+        error: string;
+        code: string;
+    }>;
+    getById(id: string): Promise<{
+        id: string;
+        providerId: string;
+        serviceTypeId: string;
+        customerId: string;
+        customerName: string;
+        customerEmail: string;
+        customerPhone: string | null;
+        startTime: Date;
+        endTime: Date;
+        status: string;
+        paymentMethod: string;
+        notes: string | null;
+        cancellationReason: string | null;
+        rescheduledFromId: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    listByCustomer(customerId: string): Promise<{
+        id: string;
+        providerId: string;
+        serviceTypeId: string;
+        customerId: string;
+        customerName: string;
+        customerEmail: string;
+        customerPhone: string | null;
+        startTime: Date;
+        endTime: Date;
+        status: string;
+        paymentMethod: string;
+        notes: string | null;
+        cancellationReason: string | null;
+        rescheduledFromId: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    listByProvider(providerId: string, from?: Date, to?: Date): Promise<{
+        id: string;
+        providerId: string;
+        serviceTypeId: string;
+        customerId: string;
+        customerName: string;
+        customerEmail: string;
+        customerPhone: string | null;
+        startTime: Date;
+        endTime: Date;
+        status: string;
+        paymentMethod: string;
+        notes: string | null;
+        cancellationReason: string | null;
+        rescheduledFromId: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
+    changeStatus(id: string, newStatus: BookingStatus, reason?: string): Promise<{
+        ok: true;
+        booking: typeof bookings.$inferSelect;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    cancel(id: string, reason?: string): Promise<{
+        ok: true;
+        booking: typeof bookings.$inferSelect;
+        refunded: boolean;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    reschedule(bookingId: string, newStartTime: Date, txDb?: Db): Promise<{
+        ok: true;
+        oldBooking: typeof bookings.$inferSelect;
+        newBooking: typeof bookings.$inferSelect;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    markNoShow(id: string): Promise<{
+        ok: true;
+        booking: typeof bookings.$inferSelect;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    complete(id: string): Promise<{
+        ok: true;
+        booking: typeof bookings.$inferSelect;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=booking-service.d.ts.map

package/dist/services/booking-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booking-service.d.ts","sourceRoot":"","sources":["../../src/services/booking-service.ts"],"names":[],"mappings":"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"}

package/dist/services/booking-service.js

@@ -0,0 +1,249 @@
+import { eq, and, gte, lte } from "@porulle/core/drizzle";
+import { bookings, bookingPayments, serviceTypes, providers } from "../schema.js";
+export class BookingService {
+    db;
+    slotService;
+    paymentAdapter;
+    jobs;
+    transitions = {
+        provisional: ["confirmed", "cancelled"],
+        confirmed: ["completed", "cancelled", "no_show"],
+        completed: [],
+        cancelled: [],
+        no_show: [],
+    };
+    constructor(db, slotService, paymentAdapter, jobs) {
+        this.db = db;
+        this.slotService = slotService;
+        this.paymentAdapter = paymentAdapter;
+        this.jobs = jobs;
+    }
+    async providerOrganizationId(providerId) {
+        const [row] = await this.db
+            .select({ organizationId: providers.organizationId })
+            .from(providers)
+            .where(eq(providers.id, providerId));
+        if (!row) {
+            throw new Error(`Appointment provider not found: ${providerId}`);
+        }
+        return row.organizationId;
+    }
+    async create(input, txDb) {
+        // Validate service type exists (outside transaction -- read-only, no lock needed)
+        const [service] = await this.db.select().from(serviceTypes).where(eq(serviceTypes.id, input.serviceTypeId));
+        if (!service)
+            return { ok: false, error: "Service type not found", code: "NOT_FOUND" };
+        // Validate provider exists
+        const [provider] = await this.db.select().from(providers).where(eq(providers.id, input.providerId));
+        if (!provider)
+            return { ok: false, error: "Provider not found", code: "NOT_FOUND" };
+        const durationMinutes = service.durationMinutes;
+        const endTime = new Date(input.startTime.getTime() + durationMinutes * 60_000);
+        const priceCents = service.priceCents;
+        // Create payment intent if card payment (outside transaction -- external API call)
+        let paymentIntentId;
+        let paymentIntent;
+        if (input.paymentMethod === "card" && this.paymentAdapter) {
+            const result = await this.paymentAdapter.createPaymentIntent({
+                amount: priceCents,
+                currency: service.currency,
+                orderId: `appointment-${Date.now()}`,
+                customerId: input.customerId,
+                metadata: { serviceTypeId: input.serviceTypeId, providerId: input.providerId },
+            });
+            if (!result.ok) {
+                return { ok: false, error: "Payment creation failed", code: "PAYMENT_ERROR" };
+            }
+            paymentIntentId = result.value.id;
+            paymentIntent = result.value;
+        }
+        // Conflict check + insert MUST be in a transaction for SELECT FOR UPDATE to hold the lock.
+        // Without a transaction, the row lock is released immediately after the SELECT.
+        const db = txDb ?? this.db;
+        const bookingOrError = await db.transaction(async (tx) => {
+            // Check for conflicts (SELECT FOR UPDATE holds lock until COMMIT)
+            const conflicting = await tx
+                .select()
+                .from(bookings)
+                .where(and(eq(bookings.providerId, input.providerId), lte(bookings.startTime, endTime), gte(bookings.endTime, input.startTime)))
+                .for("update");
+            const activeConflicts = conflicting.filter((b) => b.status !== "cancelled");
+            if (activeConflicts.length > 0) {
+                return { ok: false, error: "Time slot is already booked", code: "CONFLICT" };
+            }
+            const [booking] = await tx.insert(bookings).values({
+                providerId: input.providerId,
+                serviceTypeId: input.serviceTypeId,
+                customerId: input.customerId,
+                customerName: input.customerName,
+                customerEmail: input.customerEmail,
+                customerPhone: input.customerPhone,
+                startTime: input.startTime,
+                endTime,
+                status: "provisional",
+                paymentMethod: input.paymentMethod,
+                notes: input.notes,
+                metadata: input.metadata ?? {},
+            }).returning();
+            // Create payment record if card payment
+            if (paymentIntentId && booking) {
+                await tx.insert(bookingPayments).values({
+                    bookingId: booking.id,
+                    amountCents: priceCents,
+                    currency: service.currency,
+                    status: "pending",
+                    paymentIntentId,
+                });
+            }
+            return { ok: true, booking: booking };
+        });
+        if (!bookingOrError.ok) {
+            return bookingOrError;
+        }
+        // Enqueue notification jobs (fire-and-forget, must not block the response)
+        if (this.jobs) {
+            const bk = bookingOrError.booking;
+            const organizationId = provider.organizationId;
+            const startMs = bk.startTime.getTime();
+            // 24h reminder
+            const r24 = startMs - 24 * 60 * 60_000 - Date.now();
+            if (r24 > 0) {
+                this.jobs.enqueue("appointment:reminder", { bookingId: bk.id, customerEmail: bk.customerEmail, reminderType: "24h" }, { organizationId, delayMs: r24 }).catch(() => { });
+            }
+            // 1h reminder
+            const r1 = startMs - 60 * 60_000 - Date.now();
+            if (r1 > 0) {
+                this.jobs.enqueue("appointment:reminder", { bookingId: bk.id, customerEmail: bk.customerEmail, reminderType: "1h" }, { organizationId, delayMs: r1 }).catch(() => { });
+            }
+            // Auto-cancel unpaid provisionals
+            if (bk.paymentMethod !== "card") {
+                const ac = startMs - 24 * 60 * 60_000 - Date.now();
+                if (ac > 0) {
+                    this.jobs.enqueue("appointment:auto-cancel", { bookingId: bk.id, reason: "Unpaid provisional auto-cancelled" }, { organizationId, delayMs: ac }).catch(() => { });
+                }
+            }
+        }
+        const result = { ok: true, booking: bookingOrError.booking };
+        if (paymentIntent)
+            result.paymentIntent = paymentIntent;
+        return result;
+    }
+    async getById(id) {
+        const [row] = await this.db.select().from(bookings).where(eq(bookings.id, id));
+        return row ?? null;
+    }
+    async listByCustomer(customerId) {
+        return this.db.select().from(bookings)
+            .where(eq(bookings.customerId, customerId))
+            .orderBy(bookings.startTime);
+    }
+    async listByProvider(providerId, from, to) {
+        const conditions = [eq(bookings.providerId, providerId)];
+        if (from)
+            conditions.push(gte(bookings.startTime, from));
+        if (to)
+            conditions.push(lte(bookings.startTime, to));
+        return this.db.select().from(bookings)
+            .where(and(...conditions))
+            .orderBy(bookings.startTime);
+    }
+    async changeStatus(id, newStatus, reason) {
+        const booking = await this.getById(id);
+        if (!booking)
+            return { ok: false, error: "Booking not found" };
+        const allowed = this.transitions[booking.status];
+        if (!allowed || !allowed.includes(newStatus)) {
+            return { ok: false, error: `Cannot transition from ${booking.status} to ${newStatus}` };
+        }
+        const updates = {
+            status: newStatus,
+            updatedAt: new Date(),
+        };
+        if (newStatus === "cancelled" && reason) {
+            updates.cancellationReason = reason;
+        }
+        const [updated] = await this.db.update(bookings)
+            .set(updates)
+            .where(eq(bookings.id, id))
+            .returning();
+        // Enqueue status-specific notifications
+        if (this.jobs && updated) {
+            const organizationId = await this.providerOrganizationId(updated.providerId);
+            if (newStatus === "confirmed") {
+                this.jobs.enqueue("appointment:confirmation-notice", { bookingId: id, customerEmail: updated.customerEmail, providerId: updated.providerId }, { organizationId }).catch(() => { });
+            }
+            else if (newStatus === "no_show") {
+                this.jobs.enqueue("appointment:no-show-notice", { bookingId: id, customerEmail: updated.customerEmail }, { organizationId }).catch(() => { });
+            }
+        }
+        return { ok: true, booking: updated };
+    }
+    async cancel(id, reason) {
+        const result = await this.changeStatus(id, "cancelled", reason);
+        if (!result.ok)
+            return result;
+        let refunded = false;
+        // Check for payment record and refund if paid
+        const [payment] = await this.db.select().from(bookingPayments)
+            .where(eq(bookingPayments.bookingId, id));
+        if (payment?.paymentIntentId && this.paymentAdapter) {
+            await this.paymentAdapter.refundPayment(payment.paymentIntentId, payment.amountCents, reason ?? "Booking cancelled");
+            await this.db.update(bookingPayments)
+                .set({ status: "refunded", refundedAt: new Date() })
+                .where(eq(bookingPayments.id, payment.id));
+            refunded = true;
+        }
+        // Enqueue cancellation notice
+        if (this.jobs) {
+            const organizationId = await this.providerOrganizationId(result.booking.providerId);
+            this.jobs.enqueue("appointment:cancellation-notice", { bookingId: id, customerEmail: result.booking.customerEmail }, { organizationId }).catch(() => { });
+        }
+        return { ok: true, booking: result.booking, refunded };
+    }
+    async reschedule(bookingId, newStartTime, txDb) {
+        const db = txDb ?? this.db;
+        const existing = await this.getById(bookingId);
+        if (!existing)
+            return { ok: false, error: "Booking not found" };
+        if (existing.status === "cancelled" || existing.status === "completed" || existing.status === "no_show") {
+            return { ok: false, error: `Cannot reschedule a ${existing.status} booking` };
+        }
+        // Cancel old booking
+        const cancelResult = await this.changeStatus(bookingId, "cancelled", "Rescheduled");
+        if (!cancelResult.ok)
+            return cancelResult;
+        // Create new booking
+        const createResult = await this.create({
+            providerId: existing.providerId,
+            serviceTypeId: existing.serviceTypeId,
+            customerId: existing.customerId,
+            customerName: existing.customerName,
+            customerEmail: existing.customerEmail,
+            customerPhone: existing.customerPhone ?? undefined,
+            startTime: newStartTime,
+            paymentMethod: existing.paymentMethod,
+            notes: existing.notes ?? undefined,
+            metadata: { ...(existing.metadata ?? {}), rescheduledFromId: bookingId },
+        }, db);
+        if (!createResult.ok) {
+            return { ok: false, error: createResult.error };
+        }
+        // Update the new booking to reference the old one
+        await db.update(bookings)
+            .set({ rescheduledFromId: bookingId })
+            .where(eq(bookings.id, createResult.booking.id));
+        return { ok: true, oldBooking: cancelResult.booking, newBooking: createResult.booking };
+    }
+    async markNoShow(id) {
+        return this.changeStatus(id, "no_show");
+    }
+    async complete(id) {
+        return this.changeStatus(id, "confirmed").then((r) => {
+            if (!r.ok) {
+                // Try direct to completed if already confirmed
+                return this.changeStatus(id, "completed");
+            }
+            return this.changeStatus(id, "completed");
+        });
+    }
+}