@thebookingkit/server 0.1.2 → 0.1.3

package/src/auth.ts

@@ -1,146 +0,0 @@
-import { UnauthorizedError, ForbiddenError } from "@thebookingkit/core";
-
-/** Represents an authenticated user in the system */
-export interface AuthUser {
-  id: string;
-  email: string;
-  name?: string;
-  role?: "admin" | "provider" | "customer";
-}
-
-/** Session returned by the auth adapter */
-export interface AuthSession {
-  user: AuthUser;
-  expires: Date;
-}
-
-/**
- * Pluggable authentication adapter interface.
- * Default implementation uses NextAuth.js.
- * Swap to Supabase Auth, Clerk, or Lucia by implementing this interface.
- */
-export interface AuthAdapter {
-  /** Get the currently authenticated user from the request */
-  getCurrentUser(request: Request): Promise<AuthUser | null>;
-  /** Get the full session */
-  getSession(request: Request): Promise<AuthSession | null>;
-  /** Verify an API token or signed booking token */
-  verifyToken(token: string): Promise<AuthUser | null>;
-}
-
-/** Request with injected auth context */
-export interface AuthenticatedRequest extends Request {
-  user: AuthUser;
-}
-
-/** Options for the withAuth middleware */
-export interface WithAuthOptions {
-  /** Require a specific role */
-  requiredRole?: "admin" | "provider" | "customer";
-}
-
-/**
- * Middleware wrapper that injects the authenticated user into every request.
- *
- * - Rejects unauthenticated requests with 401.
- * - Optionally checks user role.
- * - Passes the authenticated user to the handler.
- *
- * @example
- * ```ts
- * // In a Next.js API route
- * export const GET = withAuth(authAdapter, async (req) => {
- *   const userId = req.user.id;
- *   // Provider can only access their own data
- *   const bookings = await db.query.bookings.findMany({
- *     where: eq(bookings.providerId, userId)
- *   });
- *   return Response.json(bookings);
- * });
- * ```
- */
-export function withAuth(
-  adapter: AuthAdapter,
-  handler: (req: AuthenticatedRequest) => Promise<Response>,
-  options?: WithAuthOptions,
-): (req: Request) => Promise<Response> {
-  return async (req: Request): Promise<Response> => {
-    try {
-      // Try to get user from session first
-      let user = await adapter.getCurrentUser(req);
-
-      // If no session, try Bearer token
-      if (!user) {
-        const authHeader = req.headers.get("authorization");
-        if (authHeader?.startsWith("Bearer ")) {
-          const token = authHeader.slice(7);
-          user = await adapter.verifyToken(token);
-        }
-      }
-
-      if (!user) {
-        throw new UnauthorizedError();
-      }
-
-      // Check required role if specified
-      if (options?.requiredRole && user.role !== options.requiredRole) {
-        throw new ForbiddenError();
-      }
-
-      // Inject user into request
-      const authReq = req as AuthenticatedRequest;
-      authReq.user = user;
-
-      return await handler(authReq);
-    } catch (error) {
-      if (error instanceof UnauthorizedError) {
-        return Response.json(
-          { error: error.message, code: error.code },
-          { status: 401 },
-        );
-      }
-      if (error instanceof ForbiddenError) {
-        return Response.json(
-          { error: error.message, code: error.code },
-          { status: 403 },
-        );
-      }
-      throw error;
-    }
-  };
-}
-
-/**
- * Helper to scope database queries to the authenticated user.
- * Providers can only access their own rows (user_id matches).
- *
- * @example
- * ```ts
- * const provider = await assertOwnership(db, providers, req.user.id, providerId);
- * ```
- */
-export function assertProviderOwnership(
-  userId: string,
-  resourceUserId: string,
-): void {
-  if (userId !== resourceUserId) {
-    throw new ForbiddenError(
-      "You do not have permission to access this provider's data.",
-    );
-  }
-}
-
-/**
- * Helper to verify customer access to their own bookings.
- * Customers can only access bookings where customer_email matches.
- */
-export function assertCustomerAccess(
-  userEmail: string,
-  bookingCustomerEmail: string,
-): void {
-  if (userEmail !== bookingCustomerEmail) {
-    throw new ForbiddenError(
-      "You do not have permission to access this booking.",
-    );
-  }
-}

package/src/booking-tokens.ts

@@ -1,61 +0,0 @@
-import { createHmac } from "crypto";
-
-/**
- * Generate a signed booking management token.
- *
- * The token is a signed payload containing the booking ID and expiry time.
- * It allows customers to view/manage their booking without authentication.
- *
- * @param bookingId - The booking UUID
- * @param expiresAt - When the token expires
- * @param secret - HMAC signing secret
- */
-export function generateBookingToken(
-  bookingId: string,
-  expiresAt: Date,
-  secret: string,
-): string {
-  const payload = `${bookingId}:${expiresAt.getTime()}`;
-  const signature = createHmac("sha256", secret)
-    .update(payload)
-    .digest("hex")
-    .slice(0, 16);
-  return Buffer.from(`${payload}:${signature}`).toString("base64url");
-}
-
-/**
- * Verify and decode a booking management token.
- *
- * @param token - The base64url-encoded token
- * @param secret - HMAC signing secret (must match generation)
- * @returns The booking ID if valid, null if invalid or expired
- */
-export function verifyBookingToken(
-  token: string,
-  secret: string,
-): { bookingId: string; expiresAt: Date } | null {
-  try {
-    const decoded = Buffer.from(token, "base64url").toString("utf-8");
-    const parts = decoded.split(":");
-    if (parts.length !== 3) return null;
-
-    const [bookingId, expiresAtStr, signature] = parts;
-    const expiresAt = new Date(Number(expiresAtStr));
-
-    // Check expiry
-    if (expiresAt < new Date()) return null;
-
-    // Verify signature
-    const payload = `${bookingId}:${expiresAtStr}`;
-    const expectedSig = createHmac("sha256", secret)
-      .update(payload)
-      .digest("hex")
-      .slice(0, 16);
-
-    if (signature !== expectedSig) return null;
-
-    return { bookingId, expiresAt };
-  } catch {
-    return null;
-  }
-}

package/src/index.ts

@@ -1,192 +0,0 @@
-// Re-export core errors used by server modules
-export {
-  BookingConflictError,
-  SerializationRetryExhaustedError,
-  UnauthorizedError,
-  ForbiddenError,
-} from "@thebookingkit/core";
-
-// Serialization retry utility
-export {
-  withSerializableRetry,
-  type SerializableRetryOptions,
-} from "./serialization-retry.js";
-
-// Auth middleware & adapters
-export {
-  withAuth,
-  assertProviderOwnership,
-  assertCustomerAccess,
-  type AuthUser,
-  type AuthSession,
-  type AuthAdapter,
-  type AuthenticatedRequest,
-  type WithAuthOptions,
-} from "./auth.js";
-
-// Adapters
-export type {
-  EmailAdapter,
-  SendEmailOptions,
-  EmailResult,
-  EmailDeliveryStatus,
-  EmailAttachment,
-  CalendarAdapter,
-  CalendarEventOptions,
-  CalendarEventResult,
-  CalendarConflict,
-  JobAdapter,
-  StorageAdapter,
-  SmsAdapter,
-  SendSmsOptions,
-  SmsResult,
-  PaymentAdapter,
-  CreatePaymentIntentOptions,
-  CreatePaymentIntentResult,
-  CreateSetupIntentOptions,
-  CreateSetupIntentResult,
-  CaptureResult,
-  RefundResult,
-} from "./adapters/index.js";
-export { generateICSAttachment, JOB_NAMES } from "./adapters/index.js";
-
-// Booking Tokens
-export {
-  generateBookingToken,
-  verifyBookingToken,
-} from "./booking-tokens.js";
-
-// Notification Jobs
-export {
-  sendConfirmationEmail,
-  sendReminderEmail,
-  sendCancellationEmail,
-  sendRescheduleEmail,
-  scheduleAutoReject,
-  syncBookingToCalendar,
-  deleteBookingFromCalendar,
-  formatDateTimeForEmail,
-  formatDurationForEmail,
-  type NotificationBookingData,
-  type ConfirmationEmailPayload,
-  type ReminderEmailPayload,
-  type CancellationEmailPayload,
-  type RescheduleEmailPayload,
-  type CalendarSyncPayload,
-  type CalendarDeletePayload,
-  type AutoRejectPendingPayload,
-} from "./notification-jobs.js";
-
-// Email Templates
-export {
-  interpolateTemplate,
-  CONFIRMATION_EMAIL_HTML,
-  CONFIRMATION_EMAIL_TEXT,
-  REMINDER_EMAIL_HTML,
-  CANCELLATION_EMAIL_HTML,
-  RESCHEDULE_EMAIL_HTML,
-  type EmailTemplateVars,
-} from "./email-templates.js";
-
-// Workflows
-export {
-  resolveTemplateVariables,
-  evaluateConditions,
-  validateWorkflow,
-  matchWorkflows,
-  DEFAULT_TEMPLATES,
-  TEMPLATE_VARIABLES,
-  WorkflowValidationError,
-  type WorkflowTrigger,
-  type WorkflowActionType,
-  type ConditionOperator,
-  type WorkflowCondition,
-  type EmailActionConfig,
-  type SmsActionConfig,
-  type WebhookActionConfig,
-  type StatusUpdateActionConfig,
-  type CalendarEventActionConfig,
-  type WorkflowAction,
-  type WorkflowDefinition,
-  type WorkflowContext,
-  type WorkflowLogEntry,
-} from "./workflows.js";
-
-// Webhooks
-export {
-  signWebhookPayload,
-  verifyWebhookSignature,
-  createWebhookEnvelope,
-  resolvePayloadTemplate,
-  matchWebhookSubscriptions,
-  getRetryDelay,
-  isSuccessResponse,
-  validateWebhookSubscription,
-  WebhookValidationError,
-  DEFAULT_RETRY_CONFIG,
-  WEBHOOK_TRIGGERS,
-  SIGNATURE_HEADER,
-  TIMESTAMP_HEADER,
-  DEFAULT_TOLERANCE_SECONDS,
-  type WebhookTrigger,
-  type WebhookAttendee,
-  type WebhookPayload,
-  type WebhookEnvelope,
-  type WebhookSubscription,
-  type WebhookDeliveryResult,
-  type WebhookRetryConfig,
-  type WebhookVerificationResult,
-} from "./webhooks.js";
-
-// REST API Utilities
-export {
-  createErrorResponse,
-  createSuccessResponse,
-  createPaginatedResponse,
-  generateApiKey,
-  hashApiKey,
-  verifyApiKey,
-  hasScope,
-  isKeyExpired,
-  checkRateLimit,
-  encodeCursor,
-  decodeCursor,
-  validateSlotQueryParams,
-  parseSortParam,
-  API_ERROR_CODES,
-  type ApiError,
-  type ApiErrorResponse,
-  type ApiSuccessResponse,
-  type ApiMeta,
-  type PaginatedResponse,
-  type ApiErrorCode,
-  type ApiKeyRecord,
-  type ApiKeyScope,
-  type GeneratedApiKey,
-  type RateLimitState,
-  type RateLimitResult,
-  type ValidationDetail,
-  type ValidationResult,
-} from "./api.js";
-
-// Multi-Tenancy
-export {
-  resolveEffectiveSettings,
-  getRolePermissions,
-  roleHasPermission,
-  assertOrgPermission,
-  assertTenantScope,
-  buildOrgBookingUrl,
-  parseOrgBookingPath,
-  TenantAuthorizationError,
-  GLOBAL_DEFAULTS,
-  type OrgRole,
-  type OrgMember,
-  type OrgBranding,
-  type OrgSettings,
-  type ProviderSettings,
-  type EventTypeSettings,
-  type GlobalDefaults,
-  type ResolvedSettings,
-  type OrgPermission,
-} from "./multi-tenancy.js";

package/src/multi-tenancy.ts

@@ -1,301 +0,0 @@
-/**
- * Multi-tenancy utilities for organization-scoped deployments.
- *
- * Provides organization settings resolution, cascading defaults,
- * role-based access control, and tenant authorization helpers.
- */
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Organization member role */
-export type OrgRole = "owner" | "admin" | "member";
-
-/** Organization member */
-export interface OrgMember {
-  userId: string;
-  organizationId: string;
-  role: OrgRole;
-}
-
-/** Organization branding */
-export interface OrgBranding {
-  logoUrl?: string;
-  primaryColor?: string;
-  accentColor?: string;
-  fontFamily?: string;
-}
-
-/** Organization-level settings */
-export interface OrgSettings {
-  defaultTimezone?: string;
-  defaultCurrency?: string;
-  branding?: OrgBranding;
-  defaultBufferMinutes?: number;
-  defaultBookingLimits?: Record<string, unknown>;
-}
-
-/** Provider-level settings that can override org defaults */
-export interface ProviderSettings {
-  timezone?: string;
-  currency?: string;
-  branding?: Partial<OrgBranding>;
-  bufferMinutes?: number;
-  bookingLimits?: Record<string, unknown>;
-}
-
-/** Event type settings that can override provider defaults */
-export interface EventTypeSettings {
-  timezone?: string;
-  currency?: string;
-  bufferBefore?: number;
-  bufferAfter?: number;
-  bookingLimits?: Record<string, unknown>;
-}
-
-/** Global SlotKit defaults */
-export interface GlobalDefaults {
-  timezone: string;
-  currency: string;
-  bufferMinutes: number;
-}
-
-/** Resolved effective settings after cascading resolution */
-export interface ResolvedSettings {
-  timezone: string;
-  currency: string;
-  bufferMinutes: number;
-  branding: OrgBranding;
-  bookingLimits: Record<string, unknown>;
-}
-
-/** Permissions available in the system */
-export type OrgPermission =
-  | "manage:members"
-  | "manage:teams"
-  | "manage:event-types"
-  | "view:all-bookings"
-  | "view:own-bookings"
-  | "manage:own-availability"
-  | "view:analytics"
-  | "manage:organization";
-
-// ---------------------------------------------------------------------------
-// Errors
-// ---------------------------------------------------------------------------
-
-/** Error thrown for multi-tenancy authorization violations */
-export class TenantAuthorizationError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "TenantAuthorizationError";
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Global Defaults
-// ---------------------------------------------------------------------------
-
-/** System-wide defaults used as the base for cascading resolution */
-export const GLOBAL_DEFAULTS: GlobalDefaults = {
-  timezone: "UTC",
-  currency: "USD",
-  bufferMinutes: 0,
-};
-
-// ---------------------------------------------------------------------------
-// Settings Resolution
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve effective settings via the cascade:
- * `event_type > provider > organization > global defaults`
- *
- * @param orgSettings - Organization-level settings
- * @param providerSettings - Provider-level settings (overrides org)
- * @param eventTypeSettings - Event type settings (overrides provider)
- * @returns Fully resolved effective settings
- */
-export function resolveEffectiveSettings(
-  orgSettings?: OrgSettings | null,
-  providerSettings?: ProviderSettings | null,
-  eventTypeSettings?: EventTypeSettings | null,
-): ResolvedSettings {
-  // Start with global defaults
-  let timezone = GLOBAL_DEFAULTS.timezone;
-  let currency = GLOBAL_DEFAULTS.currency;
-  let bufferMinutes = GLOBAL_DEFAULTS.bufferMinutes;
-  let branding: OrgBranding = {};
-  let bookingLimits: Record<string, unknown> = {};
-
-  // Apply org settings
-  if (orgSettings) {
-    if (orgSettings.defaultTimezone) timezone = orgSettings.defaultTimezone;
-    if (orgSettings.defaultCurrency) currency = orgSettings.defaultCurrency;
-    if (orgSettings.defaultBufferMinutes !== undefined)
-      bufferMinutes = orgSettings.defaultBufferMinutes;
-    if (orgSettings.branding) branding = { ...branding, ...orgSettings.branding };
-    if (orgSettings.defaultBookingLimits)
-      bookingLimits = { ...orgSettings.defaultBookingLimits };
-  }
-
-  // Apply provider settings (override org)
-  if (providerSettings) {
-    if (providerSettings.timezone) timezone = providerSettings.timezone;
-    if (providerSettings.currency) currency = providerSettings.currency;
-    if (providerSettings.bufferMinutes !== undefined)
-      bufferMinutes = providerSettings.bufferMinutes;
-    if (providerSettings.branding)
-      branding = { ...branding, ...providerSettings.branding };
-    if (providerSettings.bookingLimits)
-      bookingLimits = { ...bookingLimits, ...providerSettings.bookingLimits };
-  }
-
-  // Apply event type settings (override provider)
-  if (eventTypeSettings) {
-    if (eventTypeSettings.timezone) timezone = eventTypeSettings.timezone;
-    if (eventTypeSettings.currency) currency = eventTypeSettings.currency;
-    if (eventTypeSettings.bufferBefore !== undefined)
-      bufferMinutes = eventTypeSettings.bufferBefore;
-    if (eventTypeSettings.bookingLimits)
-      bookingLimits = { ...bookingLimits, ...eventTypeSettings.bookingLimits };
-  }
-
-  return { timezone, currency, bufferMinutes, branding, bookingLimits };
-}
-
-// ---------------------------------------------------------------------------
-// Role-Based Access Control
-// ---------------------------------------------------------------------------
-
-/** Permissions granted to each role */
-const ROLE_PERMISSIONS: Record<OrgRole, OrgPermission[]> = {
-  owner: [
-    "manage:members",
-    "manage:teams",
-    "manage:event-types",
-    "view:all-bookings",
-    "view:own-bookings",
-    "manage:own-availability",
-    "view:analytics",
-    "manage:organization",
-  ],
-  admin: [
-    "manage:teams",
-    "manage:event-types",
-    "view:all-bookings",
-    "view:own-bookings",
-    "manage:own-availability",
-    "view:analytics",
-  ],
-  member: [
-    "view:own-bookings",
-    "manage:own-availability",
-  ],
-};
-
-/**
- * Get all permissions granted to a role.
- *
- * @param role - The organization role
- * @returns Array of permissions
- */
-export function getRolePermissions(role: OrgRole): OrgPermission[] {
-  return ROLE_PERMISSIONS[role] ?? [];
-}
-
-/**
- * Check if a role has a specific permission.
- *
- * @param role - The organization role
- * @param permission - The permission to check
- * @returns Whether the role has the permission
- */
-export function roleHasPermission(
-  role: OrgRole,
-  permission: OrgPermission,
-): boolean {
-  return getRolePermissions(role).includes(permission);
-}
-
-/**
- * Assert that an org member has a required permission.
- *
- * @param member - The org member
- * @param permission - The required permission
- * @throws {TenantAuthorizationError} If the member lacks the permission
- */
-export function assertOrgPermission(
-  member: OrgMember,
-  permission: OrgPermission,
-): void {
-  if (!roleHasPermission(member.role, permission)) {
-    throw new TenantAuthorizationError(
-      `Role "${member.role}" does not have permission: "${permission}"`,
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tenant Scoping
-// ---------------------------------------------------------------------------
-
-/**
- * Validate that a resource belongs to the expected organization.
- *
- * @param resourceOrgId - Organization ID on the resource
- * @param expectedOrgId - The org ID from the authenticated context
- * @throws {TenantAuthorizationError} If there is a tenant mismatch
- */
-export function assertTenantScope(
-  resourceOrgId: string | null | undefined,
-  expectedOrgId: string,
-): void {
-  if (resourceOrgId && resourceOrgId !== expectedOrgId) {
-    throw new TenantAuthorizationError(
-      "Resource does not belong to the current organization",
-    );
-  }
-}
-
-/**
- * Generate the public booking URL for an organization's provider/event type.
- *
- * @param orgSlug - Organization slug
- * @param providerSlug - Provider slug or ID
- * @param eventTypeSlug - Event type slug
- * @param baseUrl - Base URL of the application
- * @returns Full booking URL
- */
-export function buildOrgBookingUrl(
-  orgSlug: string,
-  providerSlug: string,
-  eventTypeSlug: string,
-  baseUrl: string,
-): string {
-  return `${baseUrl}/${orgSlug}/${providerSlug}/${eventTypeSlug}`;
-}
-
-/**
- * Parse an organization slug from a booking URL path.
- *
- * Expected format: `/{orgSlug}/{providerSlug}/{eventTypeSlug}`
- *
- * @param pathname - URL pathname
- * @returns Parsed segments, or null if format is invalid
- */
-export function parseOrgBookingPath(pathname: string): {
-  orgSlug: string;
-  providerSlug: string;
-  eventTypeSlug: string;
-} | null {
-  const match = pathname.match(/^\/([^/]+)\/([^/]+)\/([^/]+)$/);
-  if (!match) return null;
-
-  return {
-    orgSlug: match[1],
-    providerSlug: match[2],
-    eventTypeSlug: match[3],
-  };
-}