@agent-native/scheduling 0.1.1

package/src/server/event-types-repo.ts

@@ -0,0 +1,385 @@
+/**
+ * Data access for event types.
+ *
+ * All write paths funnel through here so ownership, slug uniqueness, and
+ * redirect history are handled consistently.
+ */
+import { eq, and, or, type SQL } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { accessFilter } from "@agent-native/core/sharing";
+import type {
+  EventType,
+  Location,
+  CustomField,
+  RecurringEventRule,
+} from "../shared/index.js";
+import { getSchedulingContext } from "./context.js";
+
+function keyFor(
+  ownerEmail: string | null,
+  teamId: string | null,
+  slug: string,
+): string {
+  if (teamId) return `team:${teamId}:${slug}`;
+  return `user:${ownerEmail ?? ""}:${slug}`;
+}
+
+function rowToEventType(row: any): EventType {
+  return {
+    id: row.id,
+    title: row.title,
+    slug: row.slug,
+    description: row.description ?? undefined,
+    length: row.length,
+    durations: parseJson<number[]>(row.durations),
+    hidden: Boolean(row.hidden),
+    position: row.position,
+    schedulingType: row.schedulingType,
+    ownerEmail: row.ownerEmail ?? undefined,
+    teamId: row.teamId ?? undefined,
+    scheduleId: row.scheduleId ?? undefined,
+    locations: parseJson<Location[]>(row.locations) ?? [],
+    customFields: parseJson<CustomField[]>(row.customFields) ?? [],
+    minimumBookingNotice: row.minimumBookingNotice,
+    beforeEventBuffer: row.beforeEventBuffer,
+    afterEventBuffer: row.afterEventBuffer,
+    slotInterval: row.slotInterval ?? null,
+    periodType: row.periodType,
+    periodDays: row.periodDays ?? undefined,
+    periodStartDate: row.periodStartDate ?? undefined,
+    periodEndDate: row.periodEndDate ?? undefined,
+    seatsPerTimeSlot: row.seatsPerTimeSlot ?? undefined,
+    requiresConfirmation: Boolean(row.requiresConfirmation),
+    disableGuests: Boolean(row.disableGuests),
+    hideCalendarNotes: Boolean(row.hideCalendarNotes),
+    successRedirectUrl: row.successRedirectUrl ?? undefined,
+    bookingLimits: parseJson(row.bookingLimits),
+    lockTimeZoneToggle: Boolean(row.lockTimeZoneToggle),
+    color: row.color ?? undefined,
+    eventName: row.eventName ?? undefined,
+    recurringEvent: parseJson(row.recurringEvent),
+    metadata: parseJson(row.metadata),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function parseJson<T = any>(str: string | null | undefined): T | undefined {
+  if (!str) return undefined;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return undefined;
+  }
+}
+
+export async function listEventTypes(params: {
+  /**
+   * If provided and `useAccessFilter` is not true, narrow rows to this owner.
+   * For org-aware list calls, prefer `useAccessFilter: true` instead.
+   */
+  ownerEmail?: string;
+  teamId?: string;
+  includeHidden?: boolean;
+  /**
+   * When true, apply the framework `accessFilter` (owner OR shared OR
+   * org-visibility OR public) instead of plain ownerEmail equality. This is
+   * the right mode for any UI/agent listing, since it admits org-shared and
+   * explicitly-shared event types in addition to the user's own.
+   */
+  useAccessFilter?: boolean;
+}): Promise<EventType[]> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  let rows: any[];
+  if (params.teamId) {
+    // Team-scoped listings. Callers are responsible for asserting team
+    // membership before invoking — the repo does not (it runs without a
+    // request context in some paths, e.g. public booking pages that
+    // explicitly pass a teamId).
+    rows = await db
+      .select()
+      .from(schema.eventTypes)
+      .where(eq(schema.eventTypes.teamId, params.teamId));
+  } else if (params.useAccessFilter) {
+    rows = await db
+      .select()
+      .from(schema.eventTypes)
+      .where(accessFilter(schema.eventTypes, schema.eventTypeShares));
+  } else if (params.ownerEmail) {
+    rows = await db
+      .select()
+      .from(schema.eventTypes)
+      .where(eq(schema.eventTypes.ownerEmail, params.ownerEmail));
+  } else {
+    // Refuse to return unscoped results. Callers must supply at least
+    // one of: teamId, useAccessFilter, or ownerEmail.
+    return [];
+  }
+  return rows
+    .filter((r: any) => (params.includeHidden ? true : !r.hidden))
+    .sort((a: any, b: any) => a.position - b.position)
+    .map(rowToEventType);
+}
+
+export async function getEventTypeById(id: string): Promise<EventType | null> {
+  const { getDb, schema } = getSchedulingContext();
+  const rows = await getDb()
+    .select()
+    .from(schema.eventTypes)
+    .where(eq(schema.eventTypes.id, id));
+  return rows[0] ? rowToEventType(rows[0]) : null;
+}
+
+export async function getEventTypeBySlug(params: {
+  ownerEmail?: string;
+  teamId?: string;
+  slug: string;
+}): Promise<EventType | null> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  let rows: any[];
+  if (params.teamId) {
+    rows = await db
+      .select()
+      .from(schema.eventTypes)
+      .where(
+        and(
+          eq(schema.eventTypes.teamId, params.teamId),
+          eq(schema.eventTypes.slug, params.slug),
+        ),
+      );
+  } else if (params.ownerEmail) {
+    rows = await db
+      .select()
+      .from(schema.eventTypes)
+      .where(
+        and(
+          eq(schema.eventTypes.ownerEmail, params.ownerEmail),
+          eq(schema.eventTypes.slug, params.slug),
+        ),
+      );
+  } else {
+    return null;
+  }
+  return rows[0] ? rowToEventType(rows[0]) : null;
+}
+
+export async function createEventType(input: {
+  ownerEmail?: string;
+  teamId?: string;
+  orgId?: string;
+  title: string;
+  slug: string;
+  length: number;
+  description?: string;
+  schedulingType?: EventType["schedulingType"];
+  locations?: Location[];
+  customFields?: CustomField[];
+  scheduleId?: string;
+  color?: string;
+  recurringEvent?: RecurringEventRule;
+}): Promise<EventType> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  const now = new Date().toISOString();
+  const id = nanoid();
+  // Default location: the user's `isDefault` conferencing credential if they
+  // have one installed (Zoom, Meet, Teams), otherwise no location — the
+  // editor will prompt them to pick.
+  const defaultLocations: Location[] =
+    input.locations ??
+    (input.ownerEmail ? await resolveDefaultLocation(input.ownerEmail) : []);
+  await db.insert(schema.eventTypes).values({
+    id,
+    title: input.title,
+    slug: input.slug,
+    description: input.description ?? null,
+    length: input.length,
+    position: 0,
+    hidden: false,
+    schedulingType: input.schedulingType ?? "personal",
+    ownerEmail: input.ownerEmail ?? null,
+    teamId: input.teamId ?? null,
+    scheduleId: input.scheduleId ?? null,
+    locations: JSON.stringify(defaultLocations),
+    customFields: input.customFields
+      ? JSON.stringify(input.customFields)
+      : JSON.stringify([]),
+    minimumBookingNotice: 0,
+    beforeEventBuffer: 0,
+    afterEventBuffer: 0,
+    slotInterval: null,
+    periodType: "rolling",
+    periodDays: 60,
+    requiresConfirmation: false,
+    disableGuests: false,
+    hideCalendarNotes: false,
+    lockTimeZoneToggle: false,
+    color: input.color ?? null,
+    recurringEvent: input.recurringEvent
+      ? JSON.stringify(input.recurringEvent)
+      : null,
+    createdAt: now,
+    updatedAt: now,
+    orgId: input.orgId ?? null,
+  });
+  const created = await getEventTypeById(id);
+  if (!created) throw new Error("Failed to create event type");
+  return created;
+}
+
+export async function updateEventType(
+  id: string,
+  patch: Partial<EventType>,
+): Promise<EventType> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  const current = await getEventTypeById(id);
+  if (!current) throw new Error(`Event type ${id} not found`);
+
+  const dbPatch: Record<string, any> = {};
+  if (patch.title != null) dbPatch.title = patch.title;
+  if (patch.slug != null && patch.slug !== current.slug) {
+    // Record slug redirect
+    const oldKey = keyFor(
+      current.ownerEmail ?? null,
+      current.teamId ?? null,
+      current.slug,
+    );
+    const newKey = keyFor(
+      current.ownerEmail ?? null,
+      current.teamId ?? null,
+      patch.slug,
+    );
+    await db
+      .insert(schema.eventTypeSlugRedirects)
+      .values({
+        oldKey,
+        newKey,
+        eventTypeId: id,
+        createdAt: new Date().toISOString(),
+      })
+      .onConflictDoNothing?.();
+    dbPatch.slug = patch.slug;
+  }
+  if (patch.description !== undefined)
+    dbPatch.description = patch.description ?? null;
+  if (patch.length != null) dbPatch.length = patch.length;
+  if (patch.durations !== undefined)
+    dbPatch.durations = patch.durations
+      ? JSON.stringify(patch.durations)
+      : null;
+  if (patch.hidden != null) dbPatch.hidden = patch.hidden;
+  if (patch.position != null) dbPatch.position = patch.position;
+  if (patch.schedulingType != null)
+    dbPatch.schedulingType = patch.schedulingType;
+  if (patch.scheduleId !== undefined)
+    dbPatch.scheduleId = patch.scheduleId ?? null;
+  if (patch.locations !== undefined)
+    dbPatch.locations = JSON.stringify(patch.locations ?? []);
+  if (patch.customFields !== undefined)
+    dbPatch.customFields = JSON.stringify(patch.customFields ?? []);
+  if (patch.minimumBookingNotice != null)
+    dbPatch.minimumBookingNotice = patch.minimumBookingNotice;
+  if (patch.beforeEventBuffer != null)
+    dbPatch.beforeEventBuffer = patch.beforeEventBuffer;
+  if (patch.afterEventBuffer != null)
+    dbPatch.afterEventBuffer = patch.afterEventBuffer;
+  if (patch.slotInterval !== undefined)
+    dbPatch.slotInterval = patch.slotInterval;
+  if (patch.periodType != null) dbPatch.periodType = patch.periodType;
+  if (patch.periodDays !== undefined)
+    dbPatch.periodDays = patch.periodDays ?? null;
+  if (patch.periodStartDate !== undefined)
+    dbPatch.periodStartDate = patch.periodStartDate ?? null;
+  if (patch.periodEndDate !== undefined)
+    dbPatch.periodEndDate = patch.periodEndDate ?? null;
+  if (patch.seatsPerTimeSlot !== undefined)
+    dbPatch.seatsPerTimeSlot = patch.seatsPerTimeSlot ?? null;
+  if (patch.requiresConfirmation != null)
+    dbPatch.requiresConfirmation = patch.requiresConfirmation;
+  if (patch.disableGuests != null) dbPatch.disableGuests = patch.disableGuests;
+  if (patch.hideCalendarNotes != null)
+    dbPatch.hideCalendarNotes = patch.hideCalendarNotes;
+  if (patch.successRedirectUrl !== undefined)
+    dbPatch.successRedirectUrl = patch.successRedirectUrl ?? null;
+  if (patch.bookingLimits !== undefined)
+    dbPatch.bookingLimits = patch.bookingLimits
+      ? JSON.stringify(patch.bookingLimits)
+      : null;
+  if (patch.lockTimeZoneToggle != null)
+    dbPatch.lockTimeZoneToggle = patch.lockTimeZoneToggle;
+  if (patch.color !== undefined) dbPatch.color = patch.color ?? null;
+  if (patch.eventName !== undefined)
+    dbPatch.eventName = patch.eventName ?? null;
+  if (patch.recurringEvent !== undefined)
+    dbPatch.recurringEvent = patch.recurringEvent
+      ? JSON.stringify(patch.recurringEvent)
+      : null;
+  if (patch.metadata !== undefined)
+    dbPatch.metadata = patch.metadata ? JSON.stringify(patch.metadata) : null;
+
+  dbPatch.updatedAt = new Date().toISOString();
+
+  await db
+    .update(schema.eventTypes)
+    .set(dbPatch)
+    .where(eq(schema.eventTypes.id, id));
+  const updated = await getEventTypeById(id);
+  if (!updated) throw new Error("Failed to update event type");
+  return updated;
+}
+
+export async function deleteEventType(id: string): Promise<void> {
+  const { getDb, schema } = getSchedulingContext();
+  await getDb().delete(schema.eventTypes).where(eq(schema.eventTypes.id, id));
+}
+
+/**
+ * Return a sensible default location for a freshly-created event type.
+ * Priority: the user's `isDefault` video conferencing credential → the
+ * first installed video credential → an empty list (editor prompts user).
+ */
+async function resolveDefaultLocation(ownerEmail: string): Promise<Location[]> {
+  const { getDb, schema } = getSchedulingContext();
+  const rows = await getDb()
+    .select()
+    .from(schema.schedulingCredentials)
+    .where(eq(schema.schedulingCredentials.userEmail, ownerEmail));
+  const videoKinds = new Set(["zoom_video", "google_meet", "teams_video"]);
+  const video = rows.filter((r: any) => videoKinds.has(r.type) && !r.invalid);
+  const preferred = video.find((r: any) => r.isDefault) ?? video[0];
+  if (!preferred) return [];
+  const kindMap: Record<string, Location["kind"]> = {
+    zoom_video: "zoom",
+    google_meet: "google-meet",
+    teams_video: "teams",
+  };
+  const kind = kindMap[preferred.type];
+  if (!kind) return [];
+  return [{ kind, credentialId: preferred.id }];
+}
+
+export async function resolveEventTypeSlug(params: {
+  ownerEmail?: string;
+  teamId?: string;
+  slug: string;
+}): Promise<EventType | null> {
+  const direct = await getEventTypeBySlug(params);
+  if (direct) return direct;
+  const { getDb, schema } = getSchedulingContext();
+  const oldKey = keyFor(
+    params.ownerEmail ?? null,
+    params.teamId ?? null,
+    params.slug,
+  );
+  const redirects = await getDb()
+    .select()
+    .from(schema.eventTypeSlugRedirects)
+    .where(eq(schema.eventTypeSlugRedirects.oldKey, oldKey));
+  if (redirects[0]?.eventTypeId) {
+    return getEventTypeById(redirects[0].eventTypeId);
+  }
+  return null;
+}

package/src/server/hooks.ts

@@ -0,0 +1,213 @@
+/**
+ * Booking lifecycle hooks → workflow / webhook dispatcher.
+ *
+ * When a booking is created / rescheduled / cancelled / no-shown, we:
+ *   - Materialize scheduled reminders for each active workflow step
+ *   - Enqueue outgoing webhook deliveries
+ *
+ * The actual reminder + webhook firing happens on a recurring job (not here).
+ */
+import { eq, and, inArray } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { Booking, Workflow, WorkflowStep } from "../shared/index.js";
+import { getSchedulingContext } from "./context.js";
+import { addMinutes } from "../core/time.js";
+
+export async function onBookingCreated(booking: Booking): Promise<void> {
+  await materializeReminders(booking, "new-booking");
+  await materializeRemindersBefore(booking);
+  await enqueueWebhooks(booking, "BOOKING_CREATED");
+}
+
+export async function onBookingRescheduled(
+  original: Booking,
+  next: Booking,
+): Promise<void> {
+  await materializeReminders(next, "reschedule");
+  await enqueueWebhooks(next, "BOOKING_RESCHEDULED");
+}
+
+export async function onBookingCancelled(booking: Booking): Promise<void> {
+  await materializeReminders(booking, "cancellation");
+  await enqueueWebhooks(booking, "BOOKING_CANCELLED");
+  // Cancel any pending before-event reminders
+  const { getDb, schema } = getSchedulingContext();
+  await getDb()
+    .update(schema.scheduledReminders)
+    .set({ sent: true, sentAt: new Date().toISOString() })
+    .where(
+      and(
+        eq(schema.scheduledReminders.bookingId, booking.id),
+        eq(schema.scheduledReminders.sent, false),
+      ),
+    );
+}
+
+export async function onBookingNoShow(booking: Booking): Promise<void> {
+  await materializeReminders(booking, "no-show");
+  await enqueueWebhooks(booking, "BOOKING_NO_SHOW");
+}
+
+async function materializeReminders(
+  booking: Booking,
+  trigger: "new-booking" | "reschedule" | "cancellation" | "no-show",
+): Promise<void> {
+  const workflows = await activeWorkflowsForEvent(booking.eventTypeId, trigger);
+  const now = new Date();
+  for (const wf of workflows) {
+    for (const step of wf.steps) {
+      const scheduledFor =
+        trigger === "new-booking" && step.offsetMinutes > 0
+          ? addMinutes(now, step.offsetMinutes)
+          : now;
+      await writeReminder(booking, step, scheduledFor);
+    }
+  }
+}
+
+async function materializeRemindersBefore(booking: Booking): Promise<void> {
+  const workflows = await activeWorkflowsForEvent(
+    booking.eventTypeId,
+    "before-event",
+  );
+  const start = new Date(booking.startTime);
+  for (const wf of workflows) {
+    for (const step of wf.steps) {
+      // offsetMinutes is how many minutes BEFORE the event
+      const scheduledFor = addMinutes(start, -Math.abs(step.offsetMinutes));
+      if (scheduledFor <= new Date()) continue;
+      await writeReminder(booking, step, scheduledFor);
+    }
+  }
+  const afterWorkflows = await activeWorkflowsForEvent(
+    booking.eventTypeId,
+    "after-event",
+  );
+  const end = new Date(booking.endTime);
+  for (const wf of afterWorkflows) {
+    for (const step of wf.steps) {
+      const scheduledFor = addMinutes(end, Math.abs(step.offsetMinutes));
+      await writeReminder(booking, step, scheduledFor);
+    }
+  }
+}
+
+async function writeReminder(
+  booking: Booking,
+  step: WorkflowStep,
+  scheduledFor: Date,
+): Promise<void> {
+  const { getDb, schema } = getSchedulingContext();
+  await getDb()
+    .insert(schema.scheduledReminders)
+    .values({
+      id: nanoid(),
+      bookingId: booking.id,
+      workflowStepId: step.id,
+      method: methodForAction(step.action),
+      scheduledFor: scheduledFor.toISOString(),
+      sent: false,
+      failed: false,
+      attempts: 0,
+      createdAt: new Date().toISOString(),
+    });
+}
+
+function methodForAction(
+  action: WorkflowStep["action"],
+): "email" | "sms" | "webhook" {
+  if (action.startsWith("sms-")) return "sms";
+  if (action === "webhook") return "webhook";
+  return "email";
+}
+
+async function activeWorkflowsForEvent(
+  eventTypeId: string,
+  trigger: string,
+): Promise<Workflow[]> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  const wfRows = await db
+    .select()
+    .from(schema.workflows)
+    .where(
+      and(
+        eq(schema.workflows.trigger, trigger as any),
+        eq(schema.workflows.disabled, false),
+      ),
+    );
+  const active = wfRows.filter((w: any) => {
+    const ids = safeJson<string[]>(w.activeOnEventTypeIds) ?? [];
+    return ids.includes(eventTypeId);
+  });
+  if (active.length === 0) return [];
+  const stepRows = await db
+    .select()
+    .from(schema.workflowSteps)
+    .where(
+      inArray(
+        schema.workflowSteps.workflowId,
+        active.map((w: any) => w.id),
+      ),
+    );
+  return active.map((w: any) => hydrateWorkflow(w, stepRows));
+}
+
+async function enqueueWebhooks(booking: Booking, event: string): Promise<void> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  const webhooks = await db.select().from(schema.webhooks);
+  const now = new Date().toISOString();
+  for (const wh of webhooks) {
+    if (!wh.active) continue;
+    const triggers = safeJson<string[]>(wh.eventTriggers) ?? [];
+    if (!triggers.includes(event)) continue;
+    if (wh.eventTypeId && wh.eventTypeId !== booking.eventTypeId) continue;
+    await db.insert(schema.webhookDeliveries).values({
+      id: nanoid(),
+      webhookId: wh.id,
+      triggeredAt: now,
+      payload: JSON.stringify({ event, booking }),
+      success: false,
+      attempts: 0,
+    });
+  }
+}
+
+function hydrateWorkflow(row: any, steps: any[]): Workflow {
+  return {
+    id: row.id,
+    name: row.name,
+    trigger: row.trigger,
+    ownerEmail: row.ownerEmail ?? undefined,
+    teamId: row.teamId ?? undefined,
+    activeOnEventTypeIds: safeJson<string[]>(row.activeOnEventTypeIds) ?? [],
+    disabled: Boolean(row.disabled),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    steps: steps
+      .filter((s) => s.workflowId === row.id)
+      .sort((a, b) => a.order - b.order)
+      .map((s) => ({
+        id: s.id,
+        order: s.order,
+        action: s.action,
+        offsetMinutes: s.offsetMinutes,
+        sendTo: s.sendTo ?? undefined,
+        emailSubject: s.emailSubject ?? undefined,
+        emailBody: s.emailBody ?? undefined,
+        smsBody: s.smsBody ?? undefined,
+        webhookUrl: s.webhookUrl ?? undefined,
+        template: s.template ?? undefined,
+      })),
+  };
+}
+
+function safeJson<T = any>(s: string | null | undefined): T | undefined {
+  if (!s) return undefined;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return undefined;
+  }
+}

package/src/server/ics.ts

@@ -0,0 +1,99 @@
+/**
+ * Minimal iCalendar (RFC 5545) generator for booking confirmation emails and
+ * the `/booking/:uid.ics` download endpoint.
+ *
+ * Not exhaustive — just enough for Apple Mail / Outlook / Gmail to render
+ * the event card correctly and for Add-to-Calendar buttons to work.
+ */
+import type { Booking } from "../shared/index.js";
+
+export function buildIcs(booking: Booking, organizerName: string): string {
+  const dtStart = toIcsDate(new Date(booking.startTime));
+  const dtEnd = toIcsDate(new Date(booking.endTime));
+  const dtStamp = toIcsDate(new Date());
+  const summary = escapeIcs(booking.title);
+  const desc = escapeIcs(
+    [
+      booking.description,
+      booking.location?.link ? `Join: ${booking.location.link}` : "",
+      booking.location?.address ? `Where: ${booking.location.address}` : "",
+    ]
+      .filter(Boolean)
+      .join("\\n"),
+  );
+  const attendees = booking.attendees
+    .map(
+      (a) =>
+        `ATTENDEE;CN=${escapeIcs(a.name)};ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;RSVP=TRUE:mailto:${a.email}`,
+    )
+    .join("\n");
+  const location = booking.location?.address
+    ? `LOCATION:${escapeIcs(booking.location.address)}`
+    : booking.location?.link
+      ? `LOCATION:${escapeIcs(booking.location.link)}`
+      : "";
+
+  const cancelled = booking.status === "cancelled";
+  return [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//agent-native//scheduling//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:" + (cancelled ? "CANCEL" : "REQUEST"),
+    "BEGIN:VEVENT",
+    `UID:${booking.iCalUid}`,
+    `SEQUENCE:${booking.iCalSequence}`,
+    `DTSTAMP:${dtStamp}`,
+    `DTSTART:${dtStart}`,
+    `DTEND:${dtEnd}`,
+    `SUMMARY:${summary}`,
+    desc && `DESCRIPTION:${desc}`,
+    location,
+    `ORGANIZER;CN=${escapeIcs(organizerName)}:mailto:${booking.hostEmail}`,
+    attendees,
+    cancelled ? "STATUS:CANCELLED" : "STATUS:CONFIRMED",
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ]
+    .filter(Boolean)
+    .join("\r\n");
+}
+
+function toIcsDate(d: Date): string {
+  return d
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}/, "");
+}
+
+function escapeIcs(s: string): string {
+  return (s ?? "")
+    .replace(/\\/g, "\\\\")
+    .replace(/;/g, "\\;")
+    .replace(/,/g, "\\,")
+    .replace(/\n/g, "\\n");
+}
+
+export function addToGoogleCalendarUrl(booking: Booking): string {
+  const params = new URLSearchParams({
+    action: "TEMPLATE",
+    text: booking.title,
+    dates: `${toIcsDate(new Date(booking.startTime))}/${toIcsDate(new Date(booking.endTime))}`,
+    details: booking.description ?? "",
+    location: booking.location?.link ?? booking.location?.address ?? "",
+  });
+  return `https://www.google.com/calendar/render?${params}`;
+}
+
+export function addToOutlookWebUrl(booking: Booking): string {
+  const params = new URLSearchParams({
+    path: "/calendar/action/compose",
+    rru: "addevent",
+    startdt: booking.startTime,
+    enddt: booking.endTime,
+    subject: booking.title,
+    body: booking.description ?? "",
+    location: booking.location?.link ?? booking.location?.address ?? "",
+  });
+  return `https://outlook.live.com/calendar/0/deeplink/compose?${params}`;
+}

package/src/server/index.ts

@@ -0,0 +1,11 @@
+export * from "./context.js";
+export * from "./bookings-repo.js";
+export * from "./event-types-repo.js";
+export * from "./schedules-repo.js";
+export * from "./availability-engine.js";
+export * from "./booking-service.js";
+export * from "./hooks.js";
+export * from "./ics.js";
+export * from "./providers/index.js";
+export * from "./video-oauth.js";
+export * from "./video-oauth-state.js";