690 files changed
+12045
-33943
No files matched your search
@@ -0,0 +1,257 @@
|
||||
import type { PrismaClient } from "@/generated/prisma/client";
|
||||
import { AppointmentStatus, CalendarSyncStatus } from "@/generated/prisma/enums";
|
||||
import { decryptToken, encryptToken } from "@/lib/security/token-encryption";
|
||||
import type { CalendarProvider } from "./calendar-provider";
|
||||
import { GoogleCalendarProvider } from "./google-calendar.provider";
|
||||
import { CalendarProviderError } from "./types";
|
||||
import type { CalendarEventInput } from "./types";
|
||||
|
||||
/**
|
||||
* Appointment → Google Calendar sync policy — the one place that decides
|
||||
* *whether* and *how* an appointment's status maps to a calendar event.
|
||||
* Provider-neutral: everything here goes through `CalendarProvider`, never
|
||||
* a Google-specific call directly (see calendar-provider.ts). Every
|
||||
* public function here is safe to call from a Server Action after an
|
||||
* appointment mutation commits — sync failures are caught and recorded,
|
||||
* never thrown, so a Google outage can never roll back or block a real
|
||||
* booking change (see the brief's explicit requirement).
|
||||
*/
|
||||
|
||||
function getProvider(): CalendarProvider {
|
||||
// Google is the only provider today — see CalendarProvider's own header
|
||||
// for why a second one is additive, not a rewrite, when needed.
|
||||
return new GoogleCalendarProvider();
|
||||
}
|
||||
|
||||
async function getValidAccessToken(
|
||||
prisma: PrismaClient,
|
||||
connection: { id: string; encryptedAccessToken: string | null; encryptedRefreshToken: string; tokenExpiresAt: Date | null },
|
||||
provider: CalendarProvider,
|
||||
): Promise<string> {
|
||||
const stillValid =
|
||||
connection.encryptedAccessToken && connection.tokenExpiresAt && connection.tokenExpiresAt.getTime() - Date.now() > 60_000;
|
||||
if (stillValid) return decryptToken(connection.encryptedAccessToken!);
|
||||
|
||||
const refreshToken = decryptToken(connection.encryptedRefreshToken);
|
||||
const refreshed = await provider.refreshAccessToken(refreshToken);
|
||||
await prisma.staffCalendarConnection.update({
|
||||
where: { id: connection.id },
|
||||
data: { encryptedAccessToken: encryptToken(refreshed.accessToken), tokenExpiresAt: refreshed.expiresAt },
|
||||
});
|
||||
return refreshed.accessToken;
|
||||
}
|
||||
|
||||
function buildEventContent(appointment: {
|
||||
id: string;
|
||||
startAt: Date;
|
||||
endAt: Date;
|
||||
status: AppointmentStatus;
|
||||
customer: { firstName: string; lastName: string };
|
||||
services: { service: { name: string } }[];
|
||||
business: { name: string; locations: { addressLine1: string; city: string; postalCode: string }[] };
|
||||
}): CalendarEventInput {
|
||||
const serviceNames = appointment.services.map((s) => s.service.name).join(", ");
|
||||
const location = appointment.business.locations[0];
|
||||
const locationLine = location ? `${location.addressLine1}, ${location.city} ${location.postalCode}` : undefined;
|
||||
const appUrl = process.env.NEXT_PUBLIC_APP_URL || "";
|
||||
|
||||
const descriptionLines = [
|
||||
`Customer: ${appointment.customer.firstName} ${appointment.customer.lastName}`,
|
||||
`Service: ${serviceNames}`,
|
||||
`Business: ${appointment.business.name}`,
|
||||
locationLine ? `Address: ${locationLine}` : undefined,
|
||||
`Reference: ${appointment.id}`,
|
||||
appUrl ? `View: ${appUrl}/staff/appointments/${appointment.id}` : undefined,
|
||||
appointment.status === AppointmentStatus.NO_SHOW ? "Status: customer did not show up." : undefined,
|
||||
].filter((line): line is string => !!line);
|
||||
|
||||
return {
|
||||
summary: `${serviceNames} — ${appointment.customer.firstName} ${appointment.customer.lastName}`,
|
||||
description: descriptionLines.join("\n"),
|
||||
location: locationLine,
|
||||
startAt: appointment.startAt,
|
||||
endAt: appointment.endAt,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Policy: PENDING appointments are never synced (an unapproved booking
|
||||
* shouldn't occupy the barber's personal calendar); CANCELLED deletes the
|
||||
* remote event outright (a cancelled slot has no reason to still show
|
||||
* busy); everything else (CONFIRMED/CHECKED_IN/IN_PROGRESS/COMPLETED/
|
||||
* NO_SHOW) creates or updates the event, with NO_SHOW additionally noting
|
||||
* the outcome in the description rather than removing the event (the
|
||||
* barber's calendar should still show they were scheduled to work).
|
||||
*/
|
||||
async function syncOneConnection(
|
||||
prisma: PrismaClient,
|
||||
params: {
|
||||
appointmentId: string;
|
||||
connection: {
|
||||
id: string;
|
||||
encryptedAccessToken: string | null;
|
||||
encryptedRefreshToken: string;
|
||||
tokenExpiresAt: Date | null;
|
||||
selectedCalendarId: string;
|
||||
};
|
||||
provider: CalendarProvider;
|
||||
},
|
||||
): Promise<void> {
|
||||
const appointment = await prisma.appointment.findUnique({
|
||||
where: { id: params.appointmentId },
|
||||
include: {
|
||||
customer: { select: { firstName: true, lastName: true } },
|
||||
services: { include: { service: { select: { name: true } } } },
|
||||
business: { select: { name: true, locations: { where: { isPrimary: true }, take: 1 } } },
|
||||
},
|
||||
});
|
||||
if (!appointment) return;
|
||||
|
||||
const provider = params.provider;
|
||||
const existing = await prisma.appointmentCalendarEvent.findUnique({
|
||||
where: { appointmentId_connectionId: { appointmentId: params.appointmentId, connectionId: params.connection.id } },
|
||||
});
|
||||
|
||||
try {
|
||||
if (appointment.status === AppointmentStatus.PENDING) return;
|
||||
|
||||
const accessToken = await getValidAccessToken(prisma, params.connection, provider);
|
||||
|
||||
if (appointment.status === AppointmentStatus.CANCELLED) {
|
||||
if (existing) {
|
||||
await provider.deleteEvent({ accessToken, calendarId: params.connection.selectedCalendarId, providerEventId: existing.providerEventId });
|
||||
await prisma.appointmentCalendarEvent.update({
|
||||
where: { id: existing.id },
|
||||
data: { status: CalendarSyncStatus.CANCELLED, lastSyncedAt: new Date(), lastSyncError: null },
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const event = buildEventContent(appointment);
|
||||
|
||||
if (existing && existing.status !== CalendarSyncStatus.CANCELLED) {
|
||||
await provider.updateEvent({
|
||||
accessToken,
|
||||
calendarId: params.connection.selectedCalendarId,
|
||||
providerEventId: existing.providerEventId,
|
||||
event,
|
||||
});
|
||||
await prisma.appointmentCalendarEvent.update({
|
||||
where: { id: existing.id },
|
||||
data: { status: CalendarSyncStatus.SYNCED, lastSyncedAt: new Date(), lastSyncError: null, sourceVersion: { increment: 1 } },
|
||||
});
|
||||
} else {
|
||||
const created = await provider.createEvent({ accessToken, calendarId: params.connection.selectedCalendarId, event });
|
||||
await prisma.appointmentCalendarEvent.upsert({
|
||||
where: { appointmentId_connectionId: { appointmentId: params.appointmentId, connectionId: params.connection.id } },
|
||||
create: {
|
||||
appointmentId: params.appointmentId,
|
||||
connectionId: params.connection.id,
|
||||
providerEventId: created.providerEventId,
|
||||
providerCalendarId: params.connection.selectedCalendarId,
|
||||
status: CalendarSyncStatus.SYNCED,
|
||||
},
|
||||
update: {
|
||||
providerEventId: created.providerEventId,
|
||||
providerCalendarId: params.connection.selectedCalendarId,
|
||||
status: CalendarSyncStatus.SYNCED,
|
||||
lastSyncedAt: new Date(),
|
||||
lastSyncError: null,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
await prisma.staffCalendarConnection.update({ where: { id: params.connection.id }, data: { lastSyncAt: new Date(), lastSyncError: null } });
|
||||
} catch (error) {
|
||||
const message = error instanceof CalendarProviderError ? error.message : "Calendar sync failed unexpectedly.";
|
||||
await prisma.staffCalendarConnection.update({ where: { id: params.connection.id }, data: { lastSyncError: message } }).catch(() => {});
|
||||
if (existing) {
|
||||
await prisma.appointmentCalendarEvent
|
||||
.update({ where: { id: existing.id }, data: { status: CalendarSyncStatus.FAILED, lastSyncError: message } })
|
||||
.catch(() => {});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Call after any appointment mutation that should be reflected in
|
||||
* calendars — confirmation, approval, reschedule, service change,
|
||||
* cancellation, no-show. Never throws; a Google failure is recorded on
|
||||
* the connection/event rows for the staff settings page to surface, not
|
||||
* propagated back to the caller (see this file's own header). If the
|
||||
* appointment was reassigned to a different staff member, the previous
|
||||
* staff member's event (if any) is cancelled first so responsibility
|
||||
* moves cleanly rather than leaving a stale duplicate.
|
||||
*/
|
||||
export async function syncAppointmentSafely(
|
||||
prisma: PrismaClient,
|
||||
appointmentId: string,
|
||||
provider: CalendarProvider = getProvider(),
|
||||
): Promise<void> {
|
||||
const appointment = await prisma.appointment.findUnique({ where: { id: appointmentId }, select: { staffId: true } });
|
||||
if (!appointment) return;
|
||||
|
||||
const staleEvents = await prisma.appointmentCalendarEvent.findMany({
|
||||
where: { appointmentId, status: { not: CalendarSyncStatus.CANCELLED }, connection: { staffId: { not: appointment.staffId } } },
|
||||
include: { connection: true },
|
||||
});
|
||||
for (const stale of staleEvents) {
|
||||
await syncOneConnection(prisma, {
|
||||
appointmentId,
|
||||
provider,
|
||||
connection: {
|
||||
id: stale.connection.id,
|
||||
encryptedAccessToken: stale.connection.encryptedAccessToken,
|
||||
encryptedRefreshToken: stale.connection.encryptedRefreshToken,
|
||||
tokenExpiresAt: stale.connection.tokenExpiresAt,
|
||||
selectedCalendarId: stale.connection.selectedCalendarId,
|
||||
},
|
||||
}).catch(() => {});
|
||||
}
|
||||
// A reassigned-away staff member's event is deleted via the CANCELLED
|
||||
// path above regardless of the appointment's own current status — it's
|
||||
// no longer this connection's appointment to reflect.
|
||||
if (staleEvents.length > 0) {
|
||||
await prisma.appointmentCalendarEvent.updateMany({
|
||||
where: { id: { in: staleEvents.map((e) => e.id) } },
|
||||
data: { status: CalendarSyncStatus.CANCELLED },
|
||||
});
|
||||
}
|
||||
|
||||
const connection = await prisma.staffCalendarConnection.findUnique({ where: { staffId: appointment.staffId } });
|
||||
if (!connection || connection.revokedAt) return;
|
||||
|
||||
await syncOneConnection(prisma, { appointmentId, connection, provider });
|
||||
}
|
||||
|
||||
/**
|
||||
* Sync every future appointment for a newly connected staff member — see
|
||||
* the brief's "Initial sync... default to the next 90 days." `provider`
|
||||
* is injectable (defaults to the real Google provider) purely so tests
|
||||
* can pass a `MockCalendarProvider` — see
|
||||
* src/services/calendar/mock-calendar.provider.ts and the brief's "Do
|
||||
* not call real Google Calendar APIs in automated tests."
|
||||
*/
|
||||
export async function runInitialSync(
|
||||
prisma: PrismaClient,
|
||||
staffId: string,
|
||||
provider: CalendarProvider = getProvider(),
|
||||
): Promise<{ synced: number }> {
|
||||
const connection = await prisma.staffCalendarConnection.findUnique({ where: { staffId } });
|
||||
if (!connection) return { synced: 0 };
|
||||
|
||||
const appointments = await prisma.appointment.findMany({
|
||||
where: {
|
||||
staffId,
|
||||
startAt: { gte: new Date(), lte: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) },
|
||||
status: { notIn: [AppointmentStatus.PENDING, AppointmentStatus.CANCELLED] },
|
||||
},
|
||||
select: { id: true },
|
||||
});
|
||||
|
||||
for (const appointment of appointments) {
|
||||
await syncOneConnection(prisma, { appointmentId: appointment.id, connection, provider });
|
||||
}
|
||||
return { synced: appointments.length };
|
||||
}
|
||||
Reference in new issue
Block a user