@porulle/plugin-appointments 0.1.0

package/src/services/booking-service.ts

@@ -0,0 +1,340 @@
+import { eq, and, gte, lte } from "@porulle/core/drizzle";
+import { bookings, bookingPayments, serviceTypes, providers } 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 class BookingService {
+  private transitions: Record<string, string[]> = {
+    provisional: ["confirmed", "cancelled"],
+    confirmed: ["completed", "cancelled", "no_show"],
+    completed: [],
+    cancelled: [],
+    no_show: [],
+  };
+
+  constructor(
+    private db: Db,
+    private slotService: SlotService,
+    private paymentAdapter?: PaymentAdapterLike,
+    private jobs?: JobsAdapter,
+  ) {}
+
+  private async providerOrganizationId(providerId: string): Promise<string> {
+    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: BookingInput, txDb?: Db): Promise<{
+    ok: true;
+    booking: typeof bookings.$inferSelect;
+    paymentIntent?: { id: string; clientSecret?: string | null } | undefined;
+  } | { ok: false; error: string; code: string }> {
+    // 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: string | undefined;
+    let paymentIntent: { id: string; clientSecret?: string | null } | undefined;
+
+    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 as const, 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 as const, 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: typeof bookings.$inferSelect;
+      paymentIntent?: { id: string; clientSecret?: string | null } | undefined;
+    } = { ok: true, booking: bookingOrError.booking };
+    if (paymentIntent) result.paymentIntent = paymentIntent;
+    return result;
+  }
+
+  async getById(id: string) {
+    const [row] = await this.db.select().from(bookings).where(eq(bookings.id, id));
+    return row ?? null;
+  }
+
+  async listByCustomer(customerId: string) {
+    return this.db.select().from(bookings)
+      .where(eq(bookings.customerId, customerId))
+      .orderBy(bookings.startTime);
+  }
+
+  async listByProvider(providerId: string, from?: Date, to?: Date) {
+    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: string,
+    newStatus: BookingStatus,
+    reason?: string,
+  ): Promise<{ ok: true; booking: typeof bookings.$inferSelect } | { ok: false; error: string }> {
+    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: Record<string, unknown> = {
+      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: string,
+    reason?: string,
+  ): Promise<{ ok: true; booking: typeof bookings.$inferSelect; refunded: boolean } | { ok: false; error: string }> {
+    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: string,
+    newStartTime: Date,
+    txDb?: Db,
+  ): Promise<{ ok: true; oldBooking: typeof bookings.$inferSelect; newBooking: typeof bookings.$inferSelect } | { ok: false; error: string }> {
+    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 as "card" | "cash" | "invoice",
+      notes: existing.notes ?? undefined,
+      metadata: { ...(existing.metadata as Record<string, unknown> ?? {}), 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: string): Promise<{ ok: true; booking: typeof bookings.$inferSelect } | { ok: false; error: string }> {
+    return this.changeStatus(id, "no_show");
+  }
+
+  async complete(id: string): Promise<{ ok: true; booking: typeof bookings.$inferSelect } | { ok: false; error: string }> {
+    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");
+    });
+  }
+}

package/src/services/provider-service.ts

@@ -0,0 +1,223 @@
+import { eq, and, desc } from "@porulle/core/drizzle";
+import {
+  serviceTypes, providers, providerServices,
+  weeklyAvailability, availabilityOverrides, breaks,
+} from "../schema.js";
+import type { Db } from "../types.js";
+
+export class ProviderService {
+  constructor(private db: Db) {}
+
+  // ─── Service Types ──────────────────────────────────────────────────────────
+
+  async createServiceType(orgId: string, data: {
+    name: string;
+    slug: string;
+    description?: string;
+    durationMinutes?: number;
+    priceCents?: number;
+    currency?: string;
+    bufferBeforeMinutes?: number;
+    bufferAfterMinutes?: number;
+  }) {
+    const [row] = await this.db.insert(serviceTypes).values({
+      organizationId: orgId,
+      name: data.name,
+      slug: data.slug,
+      description: data.description,
+      durationMinutes: data.durationMinutes ?? 30,
+      priceCents: data.priceCents ?? 0,
+      currency: data.currency ?? "USD",
+      bufferBeforeMinutes: data.bufferBeforeMinutes ?? 0,
+      bufferAfterMinutes: data.bufferAfterMinutes ?? 0,
+    }).returning();
+    return row;
+  }
+
+  async getServiceType(id: string) {
+    const [row] = await this.db.select().from(serviceTypes).where(eq(serviceTypes.id, id));
+    return row ?? null;
+  }
+
+  async getServiceTypeBySlug(slug: string) {
+    const [row] = await this.db.select().from(serviceTypes).where(eq(serviceTypes.slug, slug));
+    return row ?? null;
+  }
+
+  async listServiceTypes() {
+    return this.db.select().from(serviceTypes).where(eq(serviceTypes.isActive, true)).orderBy(desc(serviceTypes.createdAt));
+  }
+
+  async updateServiceType(id: string, data: Partial<{
+    name: string; description: string; durationMinutes: number;
+    priceCents: number; currency: string;
+    bufferBeforeMinutes: number; bufferAfterMinutes: number; isActive: boolean;
+  }>) {
+    const [updated] = await this.db.update(serviceTypes)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(serviceTypes.id, id))
+      .returning();
+    return updated ?? null;
+  }
+
+  async deleteServiceType(id: string) {
+    const [deleted] = await this.db.delete(serviceTypes).where(eq(serviceTypes.id, id)).returning();
+    return deleted ?? null;
+  }
+
+  // ─── Providers ──────────────────────────────────────────────────────────────
+
+  async createProvider(orgId: string, data: {
+    name: string;
+    email?: string;
+    phone?: string;
+    timezone?: string;
+    metadata?: Record<string, unknown>;
+  }) {
+    const [row] = await this.db.insert(providers).values({
+      organizationId: orgId,
+      name: data.name,
+      email: data.email,
+      phone: data.phone,
+      timezone: data.timezone ?? "UTC",
+      metadata: data.metadata ?? {},
+    }).returning();
+    return row;
+  }
+
+  async getProvider(id: string) {
+    const [row] = await this.db.select().from(providers).where(eq(providers.id, id));
+    return row ?? null;
+  }
+
+  async listProviders() {
+    return this.db.select().from(providers).where(eq(providers.isActive, true)).orderBy(desc(providers.createdAt));
+  }
+
+  async updateProvider(id: string, data: Partial<{
+    name: string; email: string; phone: string; timezone: string; isActive: boolean;
+    metadata: Record<string, unknown>;
+  }>) {
+    const [updated] = await this.db.update(providers)
+      .set({ ...data, updatedAt: new Date() })
+      .where(eq(providers.id, id))
+      .returning();
+    return updated ?? null;
+  }
+
+  async deleteProvider(id: string) {
+    const [deleted] = await this.db.delete(providers).where(eq(providers.id, id)).returning();
+    return deleted ?? null;
+  }
+
+  // ─── Provider–ServiceType Links ─────────────────────────────────────────────
+
+  async linkServiceType(providerId: string, serviceTypeId: string, overrides?: {
+    customDurationMinutes?: number;
+    customPriceCents?: number;
+  }) {
+    const [row] = await this.db.insert(providerServices).values({
+      providerId,
+      serviceTypeId,
+      customDurationMinutes: overrides?.customDurationMinutes,
+      customPriceCents: overrides?.customPriceCents,
+    }).returning();
+    return row;
+  }
+
+  async getProviderServices(providerId: string) {
+    return this.db.select().from(providerServices)
+      .where(eq(providerServices.providerId, providerId));
+  }
+
+  // ─── Weekly Availability ────────────────────────────────────────────────────
+
+  async setWeeklyAvailability(providerId: string, schedules: Array<{
+    dayOfWeek: number;
+    startTime: string;
+    endTime: string;
+  }>) {
+    // Delete existing weekly availability for this provider
+    await this.db.delete(weeklyAvailability)
+      .where(eq(weeklyAvailability.providerId, providerId));
+
+    if (schedules.length === 0) return [];
+
+    const rows = await this.db.insert(weeklyAvailability)
+      .values(schedules.map((s) => ({
+        providerId,
+        dayOfWeek: s.dayOfWeek,
+        startTime: s.startTime,
+        endTime: s.endTime,
+      })))
+      .returning();
+
+    return rows;
+  }
+
+  async getWeeklyAvailability(providerId: string) {
+    return this.db.select().from(weeklyAvailability)
+      .where(eq(weeklyAvailability.providerId, providerId))
+      .orderBy(weeklyAvailability.dayOfWeek);
+  }
+
+  // ─── Breaks ─────────────────────────────────────────────────────────────────
+
+  async addBreak(providerId: string, data: {
+    dayOfWeek?: number | undefined;
+    startTime: string;
+    endTime: string;
+    label?: string | undefined;
+  }) {
+    const [row] = await this.db.insert(breaks).values({
+      providerId,
+      dayOfWeek: data.dayOfWeek,
+      startTime: data.startTime,
+      endTime: data.endTime,
+      label: data.label,
+    }).returning();
+    return row;
+  }
+
+  async getBreaks(providerId: string) {
+    return this.db.select().from(breaks)
+      .where(eq(breaks.providerId, providerId));
+  }
+
+  async deleteBreak(id: string) {
+    const [deleted] = await this.db.delete(breaks).where(eq(breaks.id, id)).returning();
+    return deleted ?? null;
+  }
+
+  // ─── Availability Overrides ─────────────────────────────────────────────────
+
+  async addOverride(providerId: string, data: {
+    date: string;
+    isAvailable: boolean;
+    startTime?: string | undefined;
+    endTime?: string | undefined;
+    reason?: string | undefined;
+  }) {
+    const [row] = await this.db.insert(availabilityOverrides).values({
+      providerId,
+      date: data.date,
+      isAvailable: data.isAvailable,
+      startTime: data.startTime,
+      endTime: data.endTime,
+      reason: data.reason,
+    }).returning();
+    return row;
+  }
+
+  async getOverrides(providerId: string) {
+    return this.db.select().from(availabilityOverrides)
+      .where(eq(availabilityOverrides.providerId, providerId))
+      .orderBy(availabilityOverrides.date);
+  }
+
+  async deleteOverride(id: string) {
+    const [deleted] = await this.db.delete(availabilityOverrides)
+      .where(eq(availabilityOverrides.id, id)).returning();
+    return deleted ?? null;
+  }
+}