@agent-native/scheduling 0.1.1

package/src/schema/workflows.ts

@@ -0,0 +1,128 @@
+/**
+ * Workflows — trigger-based automations ("email attendee 1h before event").
+ *
+ * Each workflow has a trigger + ordered steps. Steps run on a schedule via
+ * the framework's recurring-jobs mechanism: when a booking fires a trigger,
+ * we materialize scheduled reminders; a job processes them when due.
+ */
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+  createSharesTable,
+} from "@agent-native/core/db/schema";
+
+export const workflows = table("workflows", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  trigger: text("trigger", {
+    enum: [
+      "new-booking",
+      "before-event",
+      "after-event",
+      "reschedule",
+      "cancellation",
+      "no-show",
+    ],
+  }).notNull(),
+  teamId: text("team_id"),
+  disabled: integer("disabled", { mode: "boolean" }).notNull().default(false),
+  /** JSON array of eventTypeIds this workflow runs on. Empty = none. */
+  activeOnEventTypeIds: text("active_on_event_type_ids")
+    .notNull()
+    .default("[]"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  ...ownableColumns(),
+});
+
+export const workflowSteps = table("workflow_steps", {
+  id: text("id").primaryKey(),
+  workflowId: text("workflow_id").notNull(),
+  order: integer("order").notNull().default(0),
+  action: text("action", {
+    enum: [
+      "email-host",
+      "email-attendee",
+      "email-address",
+      "sms-attendee",
+      "sms-host",
+      "sms-number",
+      "webhook",
+    ],
+  }).notNull(),
+  /** Offset in minutes from the trigger. Negative = before (for before-event). */
+  offsetMinutes: integer("offset_minutes").notNull().default(0),
+  /** Target email / phone / url depending on action */
+  sendTo: text("send_to"),
+  emailSubject: text("email_subject"),
+  emailBody: text("email_body"),
+  smsBody: text("sms_body"),
+  webhookUrl: text("webhook_url"),
+  /** Named template key (e.g. "default-reminder") */
+  template: text("template"),
+  createdAt: text("created_at").notNull(),
+});
+
+/**
+ * Materialized reminders waiting to fire.
+ * Written by the booking-service hook when a trigger occurs.
+ * Drained by a recurring job that processes due rows.
+ */
+export const scheduledReminders = table("scheduled_reminders", {
+  id: text("id").primaryKey(),
+  bookingId: text("booking_id").notNull(),
+  workflowStepId: text("workflow_step_id").notNull(),
+  method: text("method", {
+    enum: ["email", "sms", "webhook"],
+  }).notNull(),
+  scheduledFor: text("scheduled_for").notNull(),
+  sent: integer("sent", { mode: "boolean" }).notNull().default(false),
+  sentAt: text("sent_at"),
+  failed: integer("failed", { mode: "boolean" }).notNull().default(false),
+  failureReason: text("failure_reason"),
+  attempts: integer("attempts").notNull().default(0),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Outgoing webhook subscriptions. */
+export const webhooks = table("webhooks", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  subscriberUrl: text("subscriber_url").notNull(),
+  secret: text("secret"),
+  active: integer("active", { mode: "boolean" }).notNull().default(true),
+  /** JSON array of trigger keys */
+  eventTriggers: text("event_triggers").notNull().default("[]"),
+  teamId: text("team_id"),
+  eventTypeId: text("event_type_id"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  ...ownableColumns(),
+});
+
+export const webhookDeliveries = table("webhook_deliveries", {
+  id: text("id").primaryKey(),
+  webhookId: text("webhook_id").notNull(),
+  triggeredAt: text("triggered_at").notNull(),
+  payload: text("payload").notNull(),
+  responseStatus: integer("response_status"),
+  responseBody: text("response_body"),
+  success: integer("success", { mode: "boolean" }).notNull().default(false),
+  attempts: integer("attempts").notNull().default(0),
+});
+
+/** API keys for programmatic access. */
+export const apiKeys = table("api_keys", {
+  id: text("id").primaryKey(),
+  hashedKey: text("hashed_key").notNull().unique(),
+  note: text("note"),
+  userEmail: text("user_email"),
+  teamId: text("team_id"),
+  expiresAt: text("expires_at"),
+  lastUsedAt: text("last_used_at"),
+  createdAt: text("created_at").notNull(),
+});
+
+export const workflowShares = createSharesTable("workflow_shares");

package/src/server/availability-engine.ts

@@ -0,0 +1,193 @@
+/**
+ * Availability engine — combines an event type, schedule, and calendar busy
+ * intervals into the slot list shown to the Booker.
+ *
+ * This is where the pure `computeAvailableSlots` gets plugged into the real
+ * world: it fetches the schedule, merges busy times from the selected
+ * calendars + existing bookings, and applies booking limits.
+ */
+import { inArray, eq, gte, lt, and } from "drizzle-orm";
+import type {
+  EventType,
+  Schedule,
+  BusyInterval,
+  Slot,
+} from "../shared/index.js";
+import type { BookingCounts } from "../core/limits.js";
+import { computeAvailableSlots } from "../core/slots.js";
+import { bucketKeysForSlot } from "../core/limits.js";
+import { getScheduleById } from "./schedules-repo.js";
+import { getSchedulingContext } from "./context.js";
+import { getCalendarProvider } from "./providers/registry.js";
+import { TZDate } from "@date-fns/tz";
+import { format, startOfWeek, startOfMonth, startOfYear } from "date-fns";
+
+export interface GetSlotsInput {
+  eventType: EventType;
+  /** The user we're finding availability for — their schedule + calendars. */
+  forUserEmail: string;
+  rangeStart: Date;
+  rangeEnd: Date;
+  viewerTimezone?: string;
+  now?: Date;
+}
+
+export async function getAvailableSlots(input: GetSlotsInput): Promise<Slot[]> {
+  const schedule = input.eventType.scheduleId
+    ? await getScheduleById(input.eventType.scheduleId)
+    : await resolveDefaultSchedule(input.forUserEmail);
+  if (!schedule) {
+    return [];
+  }
+  const busy = await aggregateBusy({
+    userEmail: input.forUserEmail,
+    rangeStart: input.rangeStart,
+    rangeEnd: input.rangeEnd,
+  });
+  const counts = await bookingCountsFor(
+    input.forUserEmail,
+    input.eventType.id,
+    input.viewerTimezone ?? schedule.timezone,
+  );
+  return computeAvailableSlots({
+    duration: input.eventType.length,
+    minimumBookingNotice: input.eventType.minimumBookingNotice,
+    beforeEventBuffer: input.eventType.beforeEventBuffer,
+    afterEventBuffer: input.eventType.afterEventBuffer,
+    slotInterval: input.eventType.slotInterval,
+    periodType: input.eventType.periodType,
+    periodDays: input.eventType.periodDays,
+    periodStartDate: input.eventType.periodStartDate,
+    periodEndDate: input.eventType.periodEndDate,
+    bookingLimits: input.eventType.bookingLimits,
+    schedule: {
+      timezone: schedule.timezone,
+      weeklyAvailability: schedule.weeklyAvailability,
+      dateOverrides: schedule.dateOverrides,
+    },
+    busy,
+    bookingCounts: counts,
+    rangeStart: input.rangeStart,
+    rangeEnd: input.rangeEnd,
+    now: input.now,
+    seatsPerTimeSlot: input.eventType.seatsPerTimeSlot,
+    viewerTimezone: input.viewerTimezone ?? schedule.timezone,
+  });
+}
+
+async function resolveDefaultSchedule(
+  ownerEmail: string,
+): Promise<Schedule | null> {
+  const { getDb, schema } = getSchedulingContext();
+  const rows = await getDb()
+    .select()
+    .from(schema.schedules)
+    .where(
+      and(
+        eq(schema.schedules.ownerEmail, ownerEmail),
+        eq(schema.schedules.isDefault, true),
+      ),
+    );
+  if (!rows[0]) return null;
+  return getScheduleById(rows[0].id);
+}
+
+/**
+ * Merge busy intervals from: (a) existing bookings for the user, (b) selected
+ * external calendars (via providers), (c) the calendar cache.
+ */
+export async function aggregateBusy(input: {
+  userEmail: string;
+  rangeStart: Date;
+  rangeEnd: Date;
+}): Promise<BusyInterval[]> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  const busy: BusyInterval[] = [];
+
+  // Existing bookings where this user is the host
+  const bookings = await db
+    .select()
+    .from(schema.bookings)
+    .where(
+      and(
+        eq(schema.bookings.hostEmail, input.userEmail),
+        eq(schema.bookings.status, "confirmed"),
+        gte(schema.bookings.endTime, input.rangeStart.toISOString()),
+        lt(schema.bookings.startTime, input.rangeEnd.toISOString()),
+      ),
+    );
+  for (const b of bookings) {
+    busy.push({
+      start: b.startTime,
+      end: b.endTime,
+      source: `booking:${b.uid}`,
+    });
+  }
+
+  // External calendars via registered providers
+  const creds = await db
+    .select()
+    .from(schema.schedulingCredentials)
+    .where(
+      and(
+        eq(schema.schedulingCredentials.userEmail, input.userEmail),
+        eq(schema.schedulingCredentials.invalid, false),
+      ),
+    );
+  for (const cred of creds) {
+    const selected = await db
+      .select()
+      .from(schema.selectedCalendars)
+      .where(eq(schema.selectedCalendars.credentialId, cred.id));
+    if (selected.length === 0) continue;
+    const provider = getCalendarProvider(cred.type);
+    if (!provider) continue;
+    try {
+      const result = await provider.getBusy({
+        credentialId: cred.id,
+        calendarExternalIds: selected.map((s: any) => s.externalId),
+        start: input.rangeStart,
+        end: input.rangeEnd,
+      });
+      busy.push(...result);
+    } catch (err) {
+      // Silently degrade — booking UI shows "couldn't verify availability" banner
+      // Consumer logs via their own error handler
+    }
+  }
+
+  return busy;
+}
+
+async function bookingCountsFor(
+  userEmail: string,
+  eventTypeId: string,
+  timezone: string,
+): Promise<BookingCounts> {
+  const { getDb, schema } = getSchedulingContext();
+  const rows = await getDb()
+    .select()
+    .from(schema.bookings)
+    .where(
+      and(
+        eq(schema.bookings.hostEmail, userEmail),
+        eq(schema.bookings.eventTypeId, eventTypeId),
+        eq(schema.bookings.status, "confirmed"),
+      ),
+    );
+  const counts: BookingCounts = {
+    perDay: {},
+    perWeek: {},
+    perMonth: {},
+    perYear: {},
+  };
+  for (const r of rows) {
+    const keys = bucketKeysForSlot(new Date(r.startTime), timezone);
+    counts.perDay[keys.day] = (counts.perDay[keys.day] ?? 0) + 1;
+    counts.perWeek[keys.week] = (counts.perWeek[keys.week] ?? 0) + 1;
+    counts.perMonth[keys.month] = (counts.perMonth[keys.month] ?? 0) + 1;
+    counts.perYear[keys.year] = (counts.perYear[keys.year] ?? 0) + 1;
+  }
+  return counts;
+}

package/src/server/booking-service.ts

@@ -0,0 +1,264 @@
+/**
+ * Booking lifecycle — create, reschedule, cancel — wired to providers and
+ * workflow hooks.
+ *
+ * The booking flow:
+ *   1. Load event type and resolve host (1:1, round-robin).
+ *   2. Validate requested slot against availability engine.
+ *   3. Insert the booking row + attendees.
+ *   4. For each video/calendar provider, create external events and attach
+ *      references to the booking.
+ *   5. Emit lifecycle event → workflows materialize scheduled reminders.
+ */
+import type {
+  Booking,
+  Attendee,
+  Location,
+  EventType,
+} from "../shared/index.js";
+import {
+  insertBooking,
+  getBookingByUid,
+  updateBookingStatus,
+  markAttendeeNoShow,
+  addBookingReference,
+} from "./bookings-repo.js";
+import { getEventTypeById } from "./event-types-repo.js";
+import { getCalendarProvider, getVideoProvider } from "./providers/registry.js";
+import {
+  onBookingCreated,
+  onBookingCancelled,
+  onBookingRescheduled,
+} from "./hooks.js";
+import { getSchedulingContext } from "./context.js";
+import { eq } from "drizzle-orm";
+
+export interface CreateBookingInput {
+  eventType: EventType;
+  hostEmail: string;
+  startTime: string;
+  endTime: string;
+  timezone: string;
+  title?: string;
+  description?: string;
+  location?: Location;
+  attendee: Attendee;
+  guests?: Attendee[];
+  customResponses?: Record<string, any>;
+  iCalUid?: string;
+  iCalSequence?: number;
+  orgId?: string;
+  /** If set, we're rescheduling from this booking uid */
+  fromReschedule?: string;
+}
+
+export async function createBooking(
+  input: CreateBookingInput,
+): Promise<Booking> {
+  const eventType = input.eventType;
+  const title =
+    input.title ??
+    eventType.eventName?.replace("{attendeeName}", input.attendee.name) ??
+    `${eventType.title} with ${input.attendee.name}`;
+  const attendees: Attendee[] = [input.attendee, ...(input.guests ?? [])];
+  const booking = await insertBooking({
+    eventTypeId: eventType.id,
+    hostEmail: input.hostEmail,
+    title,
+    description: input.description,
+    startTime: input.startTime,
+    endTime: input.endTime,
+    timezone: input.timezone,
+    status: eventType.requiresConfirmation ? "pending" : "confirmed",
+    location: input.location ?? eventType.locations[0],
+    attendees,
+    customResponses: input.customResponses,
+    iCalUid: input.iCalUid,
+    iCalSequence: input.iCalSequence,
+    fromReschedule: input.fromReschedule,
+    ownerEmail: input.hostEmail,
+    orgId: input.orgId,
+  });
+
+  // Create video meeting if location is a video kind
+  if (booking.location && isVideoKind(booking.location.kind)) {
+    const provider = getVideoProvider(
+      videoProviderKindFor(booking.location.kind),
+    );
+    if (provider) {
+      try {
+        const meeting = await provider.createMeeting({
+          credentialId: booking.location.credentialId,
+          booking,
+        });
+        if (meeting.meetingUrl) {
+          await addBookingReference(booking.id, {
+            type: provider.kind,
+            externalId: meeting.meetingId,
+            meetingUrl: meeting.meetingUrl,
+            meetingPassword: meeting.meetingPassword,
+            credentialId: booking.location.credentialId,
+          });
+        }
+      } catch (err) {
+        // Continue without the video link; the host can fix on the booking detail page
+      }
+    }
+  }
+
+  // Write to destination calendar
+  await writeToDestinationCalendars(booking);
+
+  // Fire workflow hooks
+  await onBookingCreated(booking);
+
+  const final = await getBookingByUid(booking.uid);
+  if (!final) throw new Error("Booking disappeared after creation");
+  return final;
+}
+
+export async function rescheduleBooking(input: {
+  uid: string;
+  newStartTime: string;
+  newEndTime: string;
+  reason?: string;
+  rescheduledBy?: "attendee" | "host";
+}): Promise<Booking> {
+  const original = await getBookingByUid(input.uid);
+  if (!original) throw new Error(`Booking ${input.uid} not found`);
+  const eventType = await getEventTypeById(original.eventTypeId);
+  if (!eventType) throw new Error("Event type missing");
+
+  // Mark old as rescheduled
+  await updateBookingStatus(input.uid, "rescheduled", {
+    reschedulingReason: input.reason,
+  });
+
+  // Create new booking linked back to the original
+  const attendee = original.attendees[0];
+  const guests = original.attendees.slice(1);
+  const newBooking = await createBooking({
+    eventType,
+    hostEmail: original.hostEmail,
+    startTime: input.newStartTime,
+    endTime: input.newEndTime,
+    timezone: original.timezone,
+    title: original.title,
+    description: original.description,
+    location: original.location,
+    attendee,
+    guests,
+    customResponses: original.customResponses,
+    iCalUid: original.iCalUid,
+    iCalSequence: original.iCalSequence + 1,
+    fromReschedule: input.uid,
+  });
+
+  // Update external calendar events (PATCH, not delete+create)
+  for (const ref of original.references) {
+    const provider = getCalendarProvider(ref.type);
+    if (provider?.updateEvent && ref.credentialId) {
+      try {
+        await provider.updateEvent({
+          credentialId: ref.credentialId,
+          externalId: ref.externalId,
+          booking: newBooking,
+        });
+      } catch {
+        // Event may have been deleted manually; fall through
+      }
+    }
+  }
+
+  await onBookingRescheduled(original, newBooking);
+  return newBooking;
+}
+
+export async function cancelBooking(input: {
+  uid: string;
+  reason?: string;
+  cancelledBy?: "attendee" | "host";
+}): Promise<Booking> {
+  const booking = await getBookingByUid(input.uid);
+  if (!booking) throw new Error(`Booking ${input.uid} not found`);
+  await updateBookingStatus(input.uid, "cancelled", {
+    cancellationReason: input.reason,
+  });
+
+  for (const ref of booking.references) {
+    const calProvider = getCalendarProvider(ref.type);
+    if (calProvider?.deleteEvent && ref.credentialId) {
+      try {
+        await calProvider.deleteEvent({
+          credentialId: ref.credentialId,
+          externalId: ref.externalId,
+        });
+      } catch {}
+    }
+    const videoProvider = getVideoProvider(ref.type);
+    if (videoProvider?.deleteMeeting) {
+      try {
+        await videoProvider.deleteMeeting({
+          credentialId: ref.credentialId,
+          meetingId: ref.externalId,
+        });
+      } catch {}
+    }
+  }
+
+  await onBookingCancelled(booking);
+  return (await getBookingByUid(input.uid))!;
+}
+
+export async function markNoShow(
+  uid: string,
+  attendeeEmail: string,
+): Promise<void> {
+  const booking = await getBookingByUid(uid);
+  if (!booking) throw new Error(`Booking ${uid} not found`);
+  await markAttendeeNoShow(booking.id, attendeeEmail);
+}
+
+function isVideoKind(kind: string): boolean {
+  return ["builtin-video", "zoom", "google-meet", "teams"].includes(kind);
+}
+
+function videoProviderKindFor(kind: string): string {
+  if (kind === "builtin-video") return "builtin_video";
+  if (kind === "zoom") return "zoom_video";
+  if (kind === "google-meet") return "google_meet";
+  if (kind === "teams") return "teams_video";
+  return kind;
+}
+
+async function writeToDestinationCalendars(booking: Booking): Promise<void> {
+  const { getDb, schema } = getSchedulingContext();
+  const db = getDb();
+  const destinations = await db
+    .select()
+    .from(schema.destinationCalendars)
+    .where(eq(schema.destinationCalendars.userEmail, booking.hostEmail));
+  for (const dest of destinations) {
+    if (dest.eventTypeId && dest.eventTypeId !== booking.eventTypeId) continue;
+    const provider = getCalendarProvider(dest.integration);
+    if (!provider) continue;
+    try {
+      const result = await provider.createEvent({
+        credentialId: dest.credentialId,
+        calendarExternalId: dest.externalId,
+        booking,
+        includeConference:
+          booking.location?.kind === "google-meet" &&
+          dest.integration === "google_calendar",
+      });
+      await addBookingReference(booking.id, {
+        type: dest.integration,
+        externalId: result.externalId,
+        meetingUrl: result.meetingUrl,
+        credentialId: dest.credentialId,
+      });
+    } catch {
+      // Calendar write failed; booking still exists locally
+    }
+  }
+}