@agent-native/scheduling 0.1.1

package/src/schema/bookings.ts

@@ -0,0 +1,124 @@
+/**
+ * Bookings — the materialized appointments created when someone books an
+ * event type.
+ *
+ * Each Booking may have multiple attendees (seated events), multiple
+ * references (one per external system: Google Calendar event id, Zoom
+ * meeting id, etc.), and a recurring parent (for recurring series).
+ */
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+  createSharesTable,
+} from "@agent-native/core/db/schema";
+
+export const bookings = table("bookings", {
+  id: text("id").primaryKey(),
+  /** Public booking uid used in URLs like /booking/:uid and /reschedule/:uid */
+  uid: text("uid").notNull().unique(),
+  eventTypeId: text("event_type_id").notNull(),
+  /** Organizer email (assigned host for round-robin) */
+  hostEmail: text("host_email").notNull(),
+
+  title: text("title").notNull(),
+  description: text("description"),
+
+  /** ISO 8601 UTC */
+  startTime: text("start_time").notNull(),
+  endTime: text("end_time").notNull(),
+  /** Timezone in which the organizer/attendees originally picked the slot */
+  timezone: text("timezone").notNull().default("UTC"),
+
+  status: text("status", {
+    enum: ["pending", "confirmed", "cancelled", "rejected", "rescheduled"],
+  })
+    .notNull()
+    .default("confirmed"),
+
+  /** JSON Location — see shared types */
+  location: text("location"),
+
+  /** JSON object of custom field responses */
+  customResponses: text("custom_responses"),
+
+  /** Reschedule/cancel tokens for public magic links */
+  cancelToken: text("cancel_token"),
+  rescheduleToken: text("reschedule_token"),
+
+  /** uid of the booking this one replaced (reschedule chain) */
+  fromReschedule: text("from_reschedule"),
+  cancellationReason: text("cancellation_reason"),
+  reschedulingReason: text("rescheduling_reason"),
+
+  /** Calendar invite iCal UID (stable across reschedules for RFC 5545 compliance) */
+  iCalUid: text("ical_uid").notNull(),
+  iCalSequence: integer("ical_sequence").notNull().default(0),
+
+  /** Recurring series parent id; null for non-recurring */
+  recurringEventId: text("recurring_event_id"),
+
+  /** Payment state (Tier 2) */
+  paid: integer("paid", { mode: "boolean" }).notNull().default(false),
+
+  /** Whether the host marked themselves a no-show */
+  noShowHost: integer("no_show_host", { mode: "boolean" })
+    .notNull()
+    .default(false),
+
+  metadata: text("metadata"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+
+  ...ownableColumns(),
+});
+
+/** Attendees attached to a booking (N for seated events, 1 for personal). */
+export const bookingAttendees = table("booking_attendees", {
+  id: text("id").primaryKey(),
+  bookingId: text("booking_id").notNull(),
+  email: text("email").notNull(),
+  name: text("name").notNull(),
+  timezone: text("timezone"),
+  locale: text("locale"),
+  noShow: integer("no_show", { mode: "boolean" }).notNull().default(false),
+  createdAt: text("created_at").notNull(),
+});
+
+/**
+ * External system references — Google Calendar event ids, Zoom meeting ids,
+ * ICS UIDs, etc. One booking → many references.
+ */
+export const bookingReferences = table("booking_references", {
+  id: text("id").primaryKey(),
+  bookingId: text("booking_id").notNull(),
+  /** Provider kind: "google_calendar", "office365_calendar", "zoom_video", … */
+  type: text("type").notNull(),
+  externalId: text("external_id").notNull(),
+  meetingUrl: text("meeting_url"),
+  meetingPassword: text("meeting_password"),
+  credentialId: text("credential_id"),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Seat reservations — one per attendee on a seated event. */
+export const bookingSeats = table("booking_seats", {
+  id: text("id").primaryKey(),
+  bookingId: text("booking_id").notNull(),
+  attendeeId: text("attendee_id").notNull(),
+  /** Opaque reference string used for attendee self-manage links */
+  referenceUid: text("reference_uid").notNull().unique(),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Internal notes on a booking (host-only). */
+export const bookingNotes = table("booking_notes", {
+  id: text("id").primaryKey(),
+  bookingId: text("booking_id").notNull(),
+  authorEmail: text("author_email").notNull(),
+  content: text("content").notNull(),
+  createdAt: text("created_at").notNull(),
+});
+
+export const bookingShares = createSharesTable("booking_shares");

package/src/schema/calendar-cache.ts

@@ -0,0 +1,23 @@
+/**
+ * Calendar cache — short-TTL cache of busy intervals fetched from external
+ * calendars. Keyed by (credentialId, selected-calendars-hash, time-window).
+ *
+ * Booking the same slot twice at 3:00pm is the worst UX in a scheduling
+ * product, so this cache has a short TTL (default 5 min) and is explicitly
+ * busted on every booking create/update/cancel.
+ */
+import { table, text, integer } from "@agent-native/core/db/schema";
+
+export const calendarCache = table("calendar_cache", {
+  id: text("id").primaryKey(),
+  credentialId: text("credential_id").notNull(),
+  /** Hash of (credentialId + sorted selected calendar ids + time range) */
+  cacheKey: text("cache_key").notNull().unique(),
+  /** ISO 8601 start of the queried window */
+  windowStart: text("window_start").notNull(),
+  windowEnd: text("window_end").notNull(),
+  /** JSON array of {start, end} busy intervals */
+  busyJson: text("busy_json").notNull(),
+  expiresAt: text("expires_at").notNull(),
+  createdAt: text("created_at").notNull(),
+});

package/src/schema/credentials.ts

@@ -0,0 +1,83 @@
+/**
+ * Credentials — thin view over framework `oauth_tokens` that records which
+ * calendar / video integrations a user has connected. The actual OAuth
+ * tokens live in core's `oauth_tokens` table; this table stores display
+ * metadata and flags needed by the scheduling UI (display name, invalid
+ * flag, app icon, default-for-type).
+ */
+import { table, text, integer } from "@agent-native/core/db/schema";
+
+export const schedulingCredentials = table("scheduling_credentials", {
+  id: text("id").primaryKey(),
+  /** Provider slug: "google_calendar", "office365_calendar", "zoom_video", "daily_video", … */
+  type: text("type").notNull(),
+  /** Owner (user) — for team credentials, use teamId too */
+  userEmail: text("user_email"),
+  teamId: text("team_id"),
+  /** App id from framework app store */
+  appId: text("app_id"),
+  /** Core `oauth_tokens.id` if applicable */
+  oauthTokenId: text("oauth_token_id"),
+  /** Human-friendly label shown in UI */
+  displayName: text("display_name"),
+  /** External account email (e.g. Google account email) */
+  externalEmail: text("external_email"),
+  /** True after a 401/403 — UI prompts re-connect */
+  invalid: integer("invalid", { mode: "boolean" }).notNull().default(false),
+  /** Whether this is the user's default for its category (e.g. default video) */
+  isDefault: integer("is_default", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+});
+
+/**
+ * Which external calendars a credential reads "busy" times from.
+ * A single credential (e.g. a Google account) may expose multiple calendars
+ * (primary, vacation, shared). Users pick a subset to check for conflicts,
+ * plus exactly one as the destination for new events.
+ */
+export const selectedCalendars = table("selected_calendars", {
+  id: text("id").primaryKey(),
+  credentialId: text("credential_id").notNull(),
+  userEmail: text("user_email").notNull(),
+  /** External calendar id from the provider */
+  externalId: text("external_id").notNull(),
+  /** Provider name for this entry */
+  integration: text("integration").notNull(),
+  /** Optional event-type-level override (only check this calendar for that event) */
+  eventTypeId: text("event_type_id"),
+  createdAt: text("created_at").notNull(),
+});
+
+export const destinationCalendars = table("destination_calendars", {
+  id: text("id").primaryKey(),
+  credentialId: text("credential_id").notNull(),
+  userEmail: text("user_email").notNull(),
+  /** Provider name */
+  integration: text("integration").notNull(),
+  externalId: text("external_id").notNull(),
+  primaryEmail: text("primary_email"),
+  /** Optional event-type-level override */
+  eventTypeId: text("event_type_id"),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Verified sender emails for workflows sending from a custom address. */
+export const verifiedEmails = table("verified_emails", {
+  id: text("id").primaryKey(),
+  email: text("email").notNull(),
+  userEmail: text("user_email"),
+  teamId: text("team_id"),
+  verifiedAt: text("verified_at").notNull(),
+});
+
+/** Verified phone numbers for workflows sending SMS. */
+export const verifiedNumbers = table("verified_numbers", {
+  id: text("id").primaryKey(),
+  phoneNumber: text("phone_number").notNull(),
+  userEmail: text("user_email"),
+  teamId: text("team_id"),
+  verifiedAt: text("verified_at").notNull(),
+});

package/src/schema/event-types.ts

@@ -0,0 +1,154 @@
+/**
+ * Event types — the top-level bookable definition.
+ *
+ * An EventType represents "a 30-minute intro call", "a team round-robin sales
+ * demo", or "a managed internal 1:1". It is the primary resource users create,
+ * edit, and share booking links for.
+ *
+ * Ownership: personal event types are owned by a user (ownerEmail);
+ * team event types are owned by a team (teamId). Sharing is via the framework
+ * sharing system (`event_type_shares`).
+ */
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+  createSharesTable,
+} from "@agent-native/core/db/schema";
+
+export const eventTypes = table("event_types", {
+  id: text("id").primaryKey(),
+
+  // Identity
+  title: text("title").notNull(),
+  slug: text("slug").notNull(),
+  description: text("description"),
+  /** Default duration in minutes */
+  length: integer("length").notNull().default(30),
+  /** JSON array of additional duration choices, e.g. [15, 30, 60] */
+  durations: text("durations"),
+  position: integer("position").notNull().default(0),
+  hidden: integer("hidden", { mode: "boolean" }).notNull().default(false),
+  color: text("color"),
+
+  // Scheduling model
+  schedulingType: text("scheduling_type", {
+    enum: ["personal", "collective", "round-robin", "managed"],
+  })
+    .notNull()
+    .default("personal"),
+  /** Team id if this is a team event type; null for personal */
+  teamId: text("team_id"),
+
+  // Locations (JSON array of Location objects)
+  locations: text("locations"),
+
+  // Custom fields (JSON array of CustomField objects)
+  customFields: text("custom_fields"),
+
+  // Default schedule reference
+  scheduleId: text("schedule_id"),
+
+  // Buffers & notice
+  minimumBookingNotice: integer("minimum_booking_notice").notNull().default(0),
+  beforeEventBuffer: integer("before_event_buffer").notNull().default(0),
+  afterEventBuffer: integer("after_event_buffer").notNull().default(0),
+  /** Slot granularity in minutes; null = use duration */
+  slotInterval: integer("slot_interval"),
+
+  // Booking window
+  periodType: text("period_type", {
+    enum: ["unlimited", "rolling", "range"],
+  })
+    .notNull()
+    .default("rolling"),
+  periodDays: integer("period_days").default(60),
+  periodStartDate: text("period_start_date"),
+  periodEndDate: text("period_end_date"),
+
+  // Capacity & policies
+  seatsPerTimeSlot: integer("seats_per_time_slot"),
+  requiresConfirmation: integer("requires_confirmation", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  disableGuests: integer("disable_guests", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  hideCalendarNotes: integer("hide_calendar_notes", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  successRedirectUrl: text("success_redirect_url"),
+  bookingLimits: text("booking_limits"),
+  /** Lock timezone on Booker (for in-person or local-only events) */
+  lockTimeZoneToggle: integer("lock_time_zone_toggle", { mode: "boolean" })
+    .notNull()
+    .default(false),
+
+  // Recurring (JSON RecurringEventRule) — Tier 2
+  recurringEvent: text("recurring_event"),
+
+  // Templated event name: "{name} + {host}"
+  eventName: text("event_name"),
+
+  // Misc
+  metadata: text("metadata"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+
+  ...ownableColumns(),
+});
+
+/**
+ * Host assignments for team / round-robin / collective event types.
+ * Composite key (userEmail, eventTypeId).
+ */
+export const eventTypeHosts = table("event_type_hosts", {
+  eventTypeId: text("event_type_id").notNull(),
+  userEmail: text("user_email").notNull(),
+  /** Fixed hosts always attend; non-fixed hosts rotate in round-robin */
+  isFixed: integer("is_fixed", { mode: "boolean" }).notNull().default(false),
+  /** Relative weight for weighted round-robin (default 1) */
+  weight: integer("weight").notNull().default(1),
+  /** Lower number = higher priority in round-robin tiebreak */
+  priority: integer("priority").notNull().default(2),
+  /** Host-specific schedule override; null = use host's default */
+  scheduleId: text("schedule_id"),
+  groupId: text("group_id"),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Host groups — collective assignment within a round-robin group. */
+export const eventTypeHostGroups = table("event_type_host_groups", {
+  id: text("id").primaryKey(),
+  eventTypeId: text("event_type_id").notNull(),
+  name: text("name").notNull(),
+  createdAt: text("created_at").notNull(),
+});
+
+/**
+ * Rename history — e.g. `/me/old-slug` → `/me/new-slug`.
+ * Public booker redirects the old slug to the new one.
+ */
+export const eventTypeSlugRedirects = table("event_type_slug_redirects", {
+  /** Composite: "ownerEmail:slug" or "team:teamId:slug" — unique across ownership scope */
+  oldKey: text("old_key").primaryKey(),
+  newKey: text("new_key").notNull(),
+  eventTypeId: text("event_type_id"),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Hashed private links (`/d/:hash/:slug`) — shareable tokens that don't expose the owner's username. */
+export const hashedLinks = table("hashed_links", {
+  id: text("id").primaryKey(),
+  hash: text("hash").notNull().unique(),
+  eventTypeId: text("event_type_id").notNull(),
+  expiresAt: text("expires_at"),
+  isSingleUse: integer("is_single_use", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  usedAt: text("used_at"),
+  createdAt: text("created_at").notNull(),
+});
+
+export const eventTypeShares = createSharesTable("event_type_shares");

package/src/schema/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Barrel export for all scheduling schema tables.
+ *
+ * Consumer apps compose this with their own schema:
+ *
+ *   // server/db/schema.ts
+ *   export * from "@agent-native/scheduling/schema";
+ *   export * from "./local-tables.js";
+ *
+ * Drizzle's schema scanner picks up all tables from the combined namespace.
+ */
+export * from "./event-types.js";
+export * from "./schedules.js";
+export * from "./bookings.js";
+export * from "./teams.js";
+export * from "./credentials.js";
+export * from "./calendar-cache.js";
+export * from "./workflows.js";
+export * from "./routing-forms.js";

package/src/schema/routing-forms.ts

@@ -0,0 +1,52 @@
+/**
+ * Routing forms — ChiliPiper-style pre-booking forms that route prospects to
+ * the right event type based on their answers.
+ *
+ * A form has fields (text/select/multi), rules (match conditions → action),
+ * and a fallback. Public form URL is `/forms/:formId`; on submit we evaluate
+ * rules in order and either redirect to an event-type booker, open an
+ * external URL, or show a custom message.
+ */
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+  createSharesTable,
+} from "@agent-native/core/db/schema";
+
+export const routingForms = table("routing_forms", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  description: text("description"),
+  teamId: text("team_id"),
+  disabled: integer("disabled", { mode: "boolean" }).notNull().default(false),
+  /** JSON array of RoutingFormField */
+  fields: text("fields").notNull().default("[]"),
+  /** JSON array of RoutingFormRule */
+  rules: text("rules").notNull().default("[]"),
+  /** JSON RoutingFormRule action object for when no rules match */
+  fallback: text("fallback"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  ...ownableColumns(),
+});
+
+export const routingFormResponses = table("routing_form_responses", {
+  id: text("id").primaryKey(),
+  formId: text("form_id").notNull(),
+  /** JSON object of fieldId → value */
+  response: text("response").notNull(),
+  /** Booking id if the response resulted in a booking */
+  bookingId: text("booking_id"),
+  /** Which rule matched (null if fallback) */
+  matchedRuleId: text("matched_rule_id"),
+  /** Resulting action description for quick filtering */
+  routedTo: text("routed_to"),
+  /** Submitter context */
+  submitterEmail: text("submitter_email"),
+  submitterIp: text("submitter_ip"),
+  createdAt: text("created_at").notNull(),
+});
+
+export const routingFormShares = createSharesTable("routing_form_shares");

package/src/schema/schedules.ts

@@ -0,0 +1,83 @@
+/**
+ * Schedules — named availability presets ("Working Hours", "Evenings").
+ *
+ * A Schedule has weekly rules (e.g. Mon-Fri 9am-5pm) stored as rows in
+ * `schedule_availability`, plus one-off overrides stored in `date_overrides`.
+ *
+ * Each user has one default schedule; event types can pick any of the user's
+ * schedules, or a host-specific override for team events.
+ */
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+  createSharesTable,
+} from "@agent-native/core/db/schema";
+
+export const schedules = table("schedules", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  timezone: text("timezone").notNull().default("UTC"),
+  isDefault: integer("is_default", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  ...ownableColumns(),
+});
+
+/**
+ * Weekly availability rules.
+ * Each row is one interval on one day-of-week for one schedule.
+ * Example: scheduleId=X, day=1 (Mon), startTime="09:00", endTime="12:00".
+ */
+export const scheduleAvailability = table("schedule_availability", {
+  id: text("id").primaryKey(),
+  scheduleId: text("schedule_id").notNull(),
+  /** 0=Sunday … 6=Saturday */
+  day: integer("day").notNull(),
+  /** "HH:MM" in schedule's timezone */
+  startTime: text("start_time").notNull(),
+  endTime: text("end_time").notNull(),
+  createdAt: text("created_at").notNull(),
+});
+
+/**
+ * Date-specific overrides.
+ * Example: scheduleId=X, date="2026-04-25", intervals=[] (fully blocked).
+ * Or intervals=[{"09:00"-"11:00"}] (only 9-11 on that day).
+ */
+export const dateOverrides = table("date_overrides", {
+  id: text("id").primaryKey(),
+  scheduleId: text("schedule_id").notNull(),
+  /** YYYY-MM-DD in schedule's timezone */
+  date: text("date").notNull(),
+  /** JSON array of {startTime,endTime}. Empty = fully blocked. */
+  intervals: text("intervals").notNull().default("[]"),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Time-zoned travel windows that override the user's default timezone. */
+export const travelSchedules = table("travel_schedules", {
+  id: text("id").primaryKey(),
+  userEmail: text("user_email").notNull(),
+  startDate: text("start_date").notNull(),
+  endDate: text("end_date").notNull(),
+  timezone: text("timezone").notNull(),
+  createdAt: text("created_at").notNull(),
+});
+
+/** Out of office — blocks bookings and optionally redirects to a coworker. */
+export const outOfOfficeEntries = table("out_of_office_entries", {
+  id: text("id").primaryKey(),
+  userEmail: text("user_email").notNull(),
+  startDate: text("start_date").notNull(),
+  endDate: text("end_date").notNull(),
+  reason: text("reason"),
+  notes: text("notes"),
+  redirectUserEmail: text("redirect_user_email"),
+  createdAt: text("created_at").notNull(),
+});
+
+export const scheduleShares = createSharesTable("schedule_shares");

package/src/schema/teams.ts

@@ -0,0 +1,46 @@
+/**
+ * Teams — groupings of users who share event types, round-robin across hosts,
+ * and present a team booking page at `/team/:slug`.
+ *
+ * Framework `org` provides heavier identity (for full multi-tenant orgs);
+ * teams here are lighter-weight and may be scoped to a single org.
+ */
+import {
+  table,
+  text,
+  integer,
+  ownableColumns,
+  createSharesTable,
+} from "@agent-native/core/db/schema";
+
+export const teams = table("teams", {
+  id: text("id").primaryKey(),
+  slug: text("slug").notNull().unique(),
+  name: text("name").notNull(),
+  logoUrl: text("logo_url"),
+  brandColor: text("brand_color"),
+  darkBrandColor: text("dark_brand_color"),
+  bio: text("bio"),
+  hideBranding: integer("hide_branding", { mode: "boolean" })
+    .notNull()
+    .default(false),
+  metadata: text("metadata"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  ...ownableColumns(),
+});
+
+export const teamMembers = table("team_members", {
+  id: text("id").primaryKey(),
+  teamId: text("team_id").notNull(),
+  userEmail: text("user_email").notNull(),
+  role: text("role", { enum: ["owner", "admin", "member"] })
+    .notNull()
+    .default("member"),
+  accepted: integer("accepted", { mode: "boolean" }).notNull().default(false),
+  inviteToken: text("invite_token"),
+  invitedAt: text("invited_at").notNull(),
+  joinedAt: text("joined_at"),
+});
+
+export const teamShares = createSharesTable("team_shares");