@nuxt-customer-portal/planning 0.4.0

package/server/utils/staff-appointments.ts

@@ -0,0 +1,158 @@
+import { randomUUID } from 'node:crypto'
+import { createError, type H3Event } from 'h3'
+import { rows, transaction } from '@nuxt-customer-portal/products/server/utils/database'
+import { parseInput } from '@nuxt-customer-portal/products/server/utils/validation'
+import { staffRescheduleSchema } from '../../shared/validation'
+import { generateSlots } from '../../shared/availability'
+import type { Appointment, AvailabilityWindow } from '../../shared/types'
+import { appointmentAccess, planningAdmin } from './access'
+import { providers, lockProvider, enqueue, bookingBusy } from './booking'
+import { getStore } from '@nuxt-customer-portal/products/server/utils/access'
+import { auditLock } from './jobs'
+import { digest } from './crypto'
+
+export async function staffReschedule(event: H3Event, id: string, body: unknown) {
+  await planningAdmin(event)
+  const input = parseInput(staffRescheduleSchema, body),
+    { appointment: initial, userId } = await appointmentAccess(event, id, true)
+  const { users } = await providers(initial.store_id, initial.product_id),
+    provider = users.find((u) => u.user_id === input.providerUserId)
+  if (!provider) {
+    throw createError({ statusCode: 409, message: 'Choose an eligible team member' })
+  }
+  if (initial.snapshot.meetingProvider === 'zoom' && (await getStore()).mode !== 'sandbox') {
+    const [connection] = await rows(
+      "SELECT user_id FROM planning.connection WHERE store_id=$1 AND user_id=$2 AND provider='zoom' AND healthy",
+      [initial.store_id, provider.user_id]
+    )
+    if (!connection) {
+      throw createError({ statusCode: 409, message: 'A healthy Zoom connection is required' })
+    }
+  }
+  const start = new Date(input.start),
+    end = new Date(start.getTime() + initial.snapshot.durationMinutes * 60000),
+    blocked = new Date(end.getTime() + provider.grace_minutes * 60000)
+  const busy = await bookingBusy(initial.store_id, provider.user_id, provider.busy_calendar_ids, start, blocked)
+  try {
+    await transaction(async (tx) => {
+      await auditLock(tx, id)
+      for (const memberId of [...new Set([initial.user_id, provider.user_id])].sort()) {
+        await lockProvider(tx, memberId)
+      }
+      const [a] = await rows<Appointment>(
+        'SELECT * FROM planning.appointment WHERE id=$1 AND store_id=$2 FOR UPDATE',
+        [id, initial.store_id],
+        tx
+      )
+      if (!a || a.status !== 'confirmed' || a.revision !== input.revision) {
+        throw createError({ statusCode: 409, message: 'Appointment changed; reload before editing' })
+      }
+      const [pending] = await rows(
+        "SELECT id FROM planning.reservation WHERE replaces_id=$1 AND status='reserved'",
+        [id],
+        tx
+      )
+      if (pending) {
+        throw createError({ statusCode: 409, message: 'Abandon or complete the pending customer change first' })
+      }
+      const [eligible] = await rows(
+        `SELECT p.user_id FROM planning.provider p JOIN public.member m ON m.user_id=p.user_id AND m.organization_id=p.store_id JOIN planning.connection c ON c.store_id=p.store_id AND c.user_id=p.user_id AND c.provider='google' AND c.healthy WHERE p.store_id=$1 AND p.user_id=$2 AND p.enabled AND p.write_calendar_id=$3 AND p.grace_minutes=$4 AND p.busy_calendar_ids=$5`,
+        [a.store_id, provider.user_id, provider.write_calendar_id, provider.grace_minutes, provider.busy_calendar_ids],
+        tx
+      )
+      const [product] = await rows(
+        `SELECT id FROM products.product WHERE id=$1 AND store_id=$2 AND data->'planning'->>'enabled'='true' AND data->'planning'->'providerUserIds' ? $3 FOR SHARE`,
+        [a.product_id, a.store_id, provider.user_id],
+        tx
+      )
+      if (!eligible || !product) {
+        throw createError({ statusCode: 409, message: 'Team member planning settings changed' })
+      }
+      const windows = await rows<{ data: AvailabilityWindow }>(
+        'SELECT data FROM planning.availability WHERE store_id=$1 AND user_id=$2 AND NOT deleted',
+        [a.store_id, provider.user_id],
+        tx
+      )
+      const internal = await rows<{ start_at: Date; blocked_until: Date }>(
+        "SELECT start_at,blocked_until FROM planning.reservation WHERE user_id=$1 AND status IN ('reserved','confirmed') AND start_at<$3 AND blocked_until>$2 AND id<>$4",
+        [provider.user_id, start, blocked, a.reservation_id],
+        tx
+      )
+      const slots = generateSlots({
+        from: start,
+        to: end,
+        now: new Date(),
+        durationMinutes: a.snapshot.durationMinutes,
+        graceMinutes: provider.grace_minutes,
+        intervalMinutes: a.snapshot.policy.slotIntervalMinutes,
+        displayIntervalMinutes: a.snapshot.policy.displayIntervalMinutes ?? 30,
+        noticeMinutes: 0,
+        horizonDays: a.snapshot.policy.bookingHorizonDays,
+        productId: a.product_id,
+        providerUserId: provider.user_id,
+        providerName: provider.name,
+        windows: windows.map((w) => w.data),
+        busy: [
+          ...busy,
+          ...internal.map((h) => ({ start: h.start_at.toISOString(), end: h.blocked_until.toISOString() }))
+        ]
+      })
+      if (!slots.some((slot) => slot.start === start.toISOString())) {
+        throw createError({ statusCode: 409, message: 'This slot is no longer available' })
+      }
+      const reservationId = randomUUID(),
+        snapshot = {
+          ...a.snapshot,
+          timezone: provider.timezone,
+          customerTimezone: input.customerTimezone,
+          graceMinutes: provider.grace_minutes
+        }
+      await tx.query("UPDATE planning.reservation SET status='superseded' WHERE id=$1", [a.reservation_id])
+      await tx.query(
+        "INSERT INTO planning.reservation(id,store_id,user_id,product_id,token_hash,start_at,end_at,blocked_until,expires_at,status,confirmed_at,replaces_id,snapshot) VALUES($1,$2,$3,$4,$5,$6,$7,$8,now(),'confirmed',now(),$9,$10)",
+        [
+          reservationId,
+          a.store_id,
+          provider.user_id,
+          a.product_id,
+          digest(randomUUID()),
+          start,
+          end,
+          blocked,
+          id,
+          snapshot
+        ]
+      )
+      if (a.user_id !== provider.user_id) {
+        await enqueue(tx, `cleanup:${id}:${a.revision}`, 'cleanup', {
+          storeId: a.store_id,
+          userId: a.calendar_user_id || a.user_id,
+          calendarId: a.calendar_id,
+          eventId: a.calendar_event_id,
+          meetingId: a.meeting_id
+        })
+      }
+      await tx.query(
+        `UPDATE planning.appointment SET reservation_id=$2,user_id=$3,start_at=$4,end_at=$5,snapshot=$6,revision=revision+1,conflict=false,effects_error=NULL,meeting_id=CASE WHEN user_id=$3 THEN meeting_id ELSE NULL END,meeting_url=CASE WHEN user_id=$3 THEN meeting_url ELSE NULL END,calendar_event_id=CASE WHEN user_id=$3 THEN calendar_event_id ELSE NULL END,calendar_id=CASE WHEN user_id=$3 THEN calendar_id ELSE NULL END,calendar_user_id=CASE WHEN user_id=$3 THEN calendar_user_id ELSE NULL END WHERE id=$1`,
+        [id, reservationId, provider.user_id, start, end, snapshot]
+      )
+      await tx.query('INSERT INTO planning.audit(id,appointment_id,actor_id,action,data) VALUES($1,$2,$3,$4,$5)', [
+        randomUUID(),
+        id,
+        userId,
+        'staff_rescheduled',
+        { previousStart: a.start_at, start, providerUserId: provider.user_id }
+      ])
+      await enqueue(tx, `appointment:${id}:${a.revision + 1}`, 'appointment', {
+        appointmentId: id,
+        revision: a.revision + 1
+      })
+    })
+  } catch (error) {
+    if ((error as { code?: string }).code === '23P01') {
+      throw createError({ statusCode: 409, message: 'This slot is no longer available' })
+    }
+    throw error
+  }
+  return { success: true }
+}

package/shared/appointment-calendar.ts

@@ -0,0 +1,82 @@
+import type { Billing, Locale } from '@nuxt-customer-portal/products/shared/types'
+
+type AppointmentCalendarDescriptionInput = {
+  start: Date
+  end: Date
+  providerTimezone: string
+  customerTimezone: string
+  locale: Locale
+  billing: Billing
+  email: string
+  meetingUrl?: string | null
+  graceMinutes: number
+}
+
+const labels = {
+  en: {
+    appointmentTime: 'Appointment time',
+    client: 'Client',
+    clientTime: 'Client time',
+    grace: (minutes: number) => `${minutes} minutes grace time after this appointment. Manage in the portal.`
+  },
+  nl: {
+    appointmentTime: 'Afspraaktijd',
+    client: 'Klant',
+    clientTime: 'Tijd van de klant',
+    grace: (minutes: number) => `${minutes} minuten uitlooptijd na deze afspraak. Beheer dit in het portaal.`
+  }
+} as const
+
+function timezoneRange(start: Date, end: Date, timezone: string, locale: Locale) {
+  const formatter = new Intl.DateTimeFormat(locale, {
+    dateStyle: 'long',
+    timeStyle: 'short',
+    timeZone: timezone
+  })
+  return formatter.formatRange(start, end)
+}
+
+function countryName(country: string, locale: Locale) {
+  if (!country) {
+    return ''
+  }
+  try {
+    return new Intl.DisplayNames([locale], { type: 'region' }).of(country.toUpperCase()) || country
+  } catch {
+    return country
+  }
+}
+
+export function appointmentCalendarTitle(title: string, billing: Billing) {
+  const clientName = billing.name || [billing.firstName, billing.lastName].filter(Boolean).join(' ')
+  return clientName ? `${clientName} - ${title}` : title
+}
+
+export function appointmentCalendarDescription(input: AppointmentCalendarDescriptionInput) {
+  const text = labels[input.locale]
+  const clientName = input.billing.name || [input.billing.firstName, input.billing.lastName].filter(Boolean).join(' ')
+  const client = [clientName, input.email, countryName(input.billing.country, input.locale)].filter(Boolean)
+  const sections = [
+    [
+      `${text.appointmentTime}:`,
+      input.providerTimezone.replaceAll('_', ' '),
+      timezoneRange(input.start, input.end, input.providerTimezone, input.locale)
+    ].join('\n'),
+    [`${text.client}:`, ...client].join('\n')
+  ]
+
+  if (input.customerTimezone && input.customerTimezone !== input.providerTimezone) {
+    sections.push(
+      [
+        `${text.clientTime}:`,
+        input.customerTimezone.replaceAll('_', ' '),
+        timezoneRange(input.start, input.end, input.customerTimezone, input.locale)
+      ].join('\n')
+    )
+  }
+  if (input.meetingUrl) {
+    sections.push(input.meetingUrl)
+  }
+  sections.push(text.grace(input.graceMinutes))
+  return sections.join('\n\n')
+}

package/shared/availability.ts

@@ -0,0 +1,140 @@
+import type { AvailabilityWindow, Interval, Slot } from './types'
+
+const minute = 60000
+const formatters = new Map<string, Intl.DateTimeFormat>()
+/** Keep display spacing anchored to local midnight, not the first remaining available slot. */
+export function isDisplaySlot(slot: Slot, timezone: string, maximumInterval = 30): boolean {
+  const interval = Math.min((Date.parse(slot.end) - Date.parse(slot.start)) / minute, maximumInterval)
+  const { time } = localParts(new Date(slot.start), timezone)
+  const wallMinutes = Number(time.slice(0, 2)) * 60 + Number(time.slice(3))
+  return interval > 0 && wallMinutes % interval === 0
+}
+export function localParts(instant: Date, timezone: string) {
+  let formatter = formatters.get(timezone)
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat('en-CA', {
+      timeZone: timezone,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      hourCycle: 'h23'
+    })
+    formatters.set(timezone, formatter)
+  }
+  const parts = formatter.formatToParts(instant)
+  const get = (key: string) => parts.find((p) => p.type === key)!.value
+  return { date: `${get('year')}-${get('month')}-${get('day')}`, time: `${get('hour')}:${get('minute')}` }
+}
+/** UTC iteration handles skipped/repeated wall-clock times without fixed offsets. */
+export function generateSlots(input: {
+  from: Date
+  to: Date
+  now: Date
+  durationMinutes: number
+  graceMinutes: number
+  intervalMinutes: number
+  displayIntervalMinutes?: number
+  noticeMinutes: number
+  horizonDays: number
+  productId: string
+  providerUserId: string
+  providerName: string
+  windows: AvailabilityWindow[]
+  busy: Interval[]
+}): Slot[] {
+  const slots: Slot[] = []
+  const busy = input.busy.map((b) => ({ start: Date.parse(b.start), end: Date.parse(b.end) }))
+  const lower = Math.max(input.from.getTime(), input.now.getTime() + input.noticeMinutes * minute)
+  const upper = Math.min(input.to.getTime(), input.now.getTime() + input.horizonDays * 86400000)
+  for (let start = Math.ceil(lower / minute) * minute; start < upper; start += minute) {
+    const end = start + input.durationMinutes * minute
+    if (end > upper) {
+      break
+    }
+    let slotTimezone = 'UTC'
+    const fits = input.windows.some((w) => {
+      if (w.productIds && !w.productIds.includes(input.productId)) {
+        return false
+      }
+      const first = localParts(new Date(start), w.timezone),
+        last = localParts(new Date(end), w.timezone)
+      const endsAtMidnight =
+        w.endTime === '24:00' && last.time === '00:00' && Date.parse(last.date) === Date.parse(first.date) + 86400000
+      if (
+        (first.date !== last.date && !endsAtMidnight) ||
+        first.date < w.date ||
+        (w.endDate && first.date > w.endDate) ||
+        w.exceptions.includes(first.date)
+      ) {
+        return false
+      }
+      if (w.recurring ? new Date(first.date).getUTCDay() !== new Date(w.date).getUTCDay() : first.date !== w.date) {
+        return false
+      }
+      const wallMinute = (s: string) => Number(s.slice(0, 2)) * 60 + Number(s.slice(3))
+      const matches =
+        first.time >= w.startTime &&
+        (endsAtMidnight || last.time <= w.endTime) &&
+        (wallMinute(first.time) - wallMinute(w.startTime)) % input.intervalMinutes === 0
+      if (matches) {
+        slotTimezone = w.timezone
+      }
+      return matches
+    })
+    if (!fits || busy.some((b) => start < b.end && end + input.graceMinutes * minute > b.start)) {
+      continue
+    }
+    const slot = {
+      start: new Date(start).toISOString(),
+      end: new Date(end).toISOString(),
+      providerUserId: input.providerUserId,
+      providerName: input.providerName
+    }
+    if (input.displayIntervalMinutes && !isDisplaySlot(slot, slotTimezone, input.displayIntervalMinutes)) {
+      continue
+    }
+    slots.push(slot)
+  }
+  return slots
+}
+export const canChange = (start: Date, now: Date, cutoffMinutes: number) =>
+  start.getTime() - now.getTime() >= cutoffMinutes * minute && start > now
+export function changeFee(changes: number, freeChanges: number, fees: Record<string, number>, currency: string) {
+  if (changes < freeChanges) {
+    return 0
+  }
+  const fee = fees[currency]
+  if (!fee) {
+    throw new Error('No change fee configured for this currency')
+  }
+  return fee
+}
+export const refundAmount = (paid: number, alreadyRefunded: number, percentage: number) =>
+  Math.max(0, Math.min(paid - alreadyRefunded, Math.round((paid * percentage) / 100)))
+
+/** Format a local wall time for calendar APIs, which require midnight as the following day's 00:00. */
+export function calendarWallDateTime(date: string, time: string) {
+  if (time !== '24:00') {
+    return `${date}T${time}:00`
+  }
+  const nextDate = new Date(`${date}T00:00:00Z`)
+  nextDate.setUTCDate(nextDate.getUTCDate() + 1)
+  return `${nextDate.toISOString().slice(0, 10)}T00:00:00`
+}
+
+/** Resolve explicit local wall time; reject nonexistent times instead of silently changing them. */
+export function wallInstant(date: string, time: string, timezone: string): Date {
+  const target = Date.parse(`${date}T${time}:00Z`)
+  let guess = target
+  for (let i = 0; i < 6; i++) {
+    const parts = localParts(new Date(guess), timezone)
+    const delta = target - Date.parse(`${parts.date}T${parts.time}:00Z`)
+    if (!delta) {
+      return new Date(guess)
+    }
+    guess += delta
+  }
+  throw new Error('This local time does not exist in the selected timezone')
+}

package/shared/emails.ts

@@ -0,0 +1,99 @@
+const appointmentPlaceholders = [
+  'recipient_name',
+  'product',
+  'time',
+  'timezone',
+  'meetingUrl',
+  'meetingDetails',
+  'instructions',
+  'url'
+].map((key) => ({
+  key,
+  labelKey: `planning.${key}`,
+  example: key === 'recipient_name' ? 'Alex' : key
+}))
+
+const appointmentStatusPlaceholders = [
+  ...appointmentPlaceholders,
+  { key: 'status', labelKey: 'planning.status', example: 'Appointment confirmed' }
+]
+
+export const newAppointmentEmail = {
+  id: 'appointment-new',
+  labelKey: 'planning.emailNewAppointment',
+  defaults: {
+    en: {
+      subject: 'Your appointment is confirmed: {{product}}',
+      body: 'Dear {{recipient_name}},\n\nYour new appointment has been confirmed. You can find the details below.\n\n- **Appointment:** {{product}}\n- **Date and time:** {{time}} ({{timezone}})\n\n{{meetingDetails}}\n\n{{instructions}}\n\nYou can review or manage your appointment at any time from [your appointments]({{url}}).',
+      footer:
+        'We look forward to seeing you. If anything changes, you can always find the most recent information through the appointment link above.'
+    },
+    nl: {
+      subject: 'Je afspraak is bevestigd: {{product}}',
+      body: 'Beste {{recipient_name}},\n\nJe nieuwe afspraak is bevestigd. Hieronder vind je de gegevens.\n\n- **Afspraak:** {{product}}\n- **Datum en tijd:** {{time}} ({{timezone}})\n\n{{meetingDetails}}\n\n{{instructions}}\n\nJe kunt je afspraak op elk moment bekijken of beheren via [je afspraken]({{url}}).',
+      footer:
+        'We kijken ernaar uit je te zien. Als er iets verandert, vind je via de bovenstaande link altijd de meest recente informatie.'
+    }
+  },
+  placeholders: appointmentPlaceholders
+}
+
+export const zoomLinkReadyEmail = {
+  id: 'appointment-zoom-ready',
+  labelKey: 'planning.emailZoomLinkReady',
+  defaults: {
+    en: {
+      subject: 'Your Zoom link is ready: {{product}}',
+      body: 'Dear {{recipient_name}},\n\nThe Zoom link for your appointment is now ready.\n\n- **Appointment:** {{product}}\n- **Date and time:** {{time}} ({{timezone}})\n\n{{meetingDetails}}\n\nYou can always find the current meeting details under [your appointments]({{url}}).',
+      footer: 'We look forward to seeing you.'
+    },
+    nl: {
+      subject: 'Je Zoom-link is gereed: {{product}}',
+      body: 'Beste {{recipient_name}},\n\nDe Zoom-link voor je afspraak is nu gereed.\n\n- **Afspraak:** {{product}}\n- **Datum en tijd:** {{time}} ({{timezone}})\n\n{{meetingDetails}}\n\nJe vindt de actuele vergadergegevens altijd bij [je afspraken]({{url}}).',
+      footer: 'We kijken ernaar uit je te zien.'
+    }
+  },
+  placeholders: appointmentPlaceholders
+}
+
+export const updatedAppointmentEmail = {
+  // Keep the original id so existing organization-specific customizations remain attached.
+  id: 'appointment',
+  labelKey: 'planning.emailUpdatedAppointment',
+  defaults: {
+    en: {
+      subject: 'Your appointment has been updated: {{product}}',
+      body: 'Dear {{recipient_name}},\n\nYour appointment has been updated. You can find the latest details below.\n\n**{{status}}**\n\n- **Appointment:** {{product}}\n- **Date and time:** {{time}} ({{timezone}})\n\n{{meetingDetails}}\n\n{{instructions}}\n\nYou can review or manage your appointment at any time from [your appointments]({{url}}).',
+      footer:
+        'We look forward to seeing you. If anything changes, you can always find the most recent information through the appointment link above.'
+    },
+    nl: {
+      subject: 'Je afspraak is bijgewerkt: {{product}}',
+      body: 'Beste {{recipient_name}},\n\nJe afspraak is bijgewerkt. Hieronder vind je de meest recente gegevens.\n\n**{{status}}**\n\n- **Afspraak:** {{product}}\n- **Datum en tijd:** {{time}} ({{timezone}})\n\n{{meetingDetails}}\n\n{{instructions}}\n\nJe kunt je afspraak op elk moment bekijken of beheren via [je afspraken]({{url}}).',
+      footer:
+        'We kijken ernaar uit je te zien. Als er iets verandert, vind je via de bovenstaande link altijd de meest recente informatie.'
+    }
+  },
+  placeholders: appointmentStatusPlaceholders
+}
+
+export const canceledAppointmentEmail = {
+  id: 'appointment-canceled',
+  labelKey: 'planning.emailCanceledAppointment',
+  defaults: {
+    en: {
+      subject: 'Your appointment has been canceled: {{product}}',
+      body: 'Dear {{recipient_name}},\n\nYour appointment has been canceled. The canceled appointment was scheduled as follows:\n\n- **Appointment:** {{product}}\n- **Date and time:** {{time}} ({{timezone}})\n\nYou can view your appointments or arrange another time from [your appointments]({{url}}).',
+      footer: 'If you have any questions about this cancellation, please contact us and we will be happy to help.'
+    },
+    nl: {
+      subject: 'Je afspraak is geannuleerd: {{product}}',
+      body: 'Beste {{recipient_name}},\n\nJe afspraak is geannuleerd. De geannuleerde afspraak stond als volgt gepland:\n\n- **Afspraak:** {{product}}\n- **Datum en tijd:** {{time}} ({{timezone}})\n\nJe kunt je afspraken bekijken of een ander tijdstip regelen via [je afspraken]({{url}}).',
+      footer: 'Heb je vragen over deze annulering? Neem dan gerust contact met ons op; we helpen je graag verder.'
+    }
+  },
+  placeholders: appointmentPlaceholders
+}
+
+// Operational notifications still use the general appointment-update template.
+export const appointmentEmail = updatedAppointmentEmail

package/shared/feature.ts

@@ -0,0 +1,78 @@
+import type { PortalFeatureDefinition } from '@nuxt-customer-portal/core/shared/types/feature'
+
+import { canceledAppointmentEmail, newAppointmentEmail, updatedAppointmentEmail, zoomLinkReadyEmail } from './emails'
+
+export const planningFeature: PortalFeatureDefinition<'manage' | 'read'> = {
+  id: 'planning',
+  emails: [newAppointmentEmail, updatedAppointmentEmail, canceledAppointmentEmail, zoomLinkReadyEmail],
+  dashboardWidgets: [
+    {
+      id: 'planning-upcoming',
+      component: 'PlanningDashboardUpcomingAppointments',
+      area: 'main',
+      size: 'half',
+      order: 5
+    },
+    {
+      id: 'planning-overview',
+      component: 'PlanningDashboardOverview',
+      area: 'main',
+      size: 'half',
+      order: 6
+    }
+  ],
+  modules: [
+    {
+      id: 'planning',
+      labelKey: 'planning.appointments',
+      icon: 'i-lucide-calendar-days',
+      to: '/availability',
+      routePrefixes: ['/appointments', '/availability', '/planning/settings', '/admin/planning'],
+      audiences: ['providerAuthenticated'],
+      menuItems: [
+        {
+          id: 'availability',
+          labelKey: 'planning.availability',
+          icon: 'i-lucide-calendar-days',
+          to: '/availability',
+          audiences: ['providerAuthenticated'],
+          exact: true
+        },
+        {
+          id: 'planning-appointments',
+          labelKey: 'planning.appointments',
+          icon: 'i-lucide-calendar-check',
+          to: '/appointments',
+          audiences: ['providerAuthenticated']
+        },
+        {
+          id: 'planning-personal-settings',
+          labelKey: 'planning.myAppointmentSettings',
+          icon: 'i-lucide-calendar-cog',
+          to: '/planning/settings',
+          audiences: ['providerAuthenticated'],
+          exact: true
+        },
+        {
+          id: 'planning-admin',
+          labelKey: 'planning.settings',
+          icon: 'i-lucide-settings',
+          to: '/admin/planning',
+          audiences: ['providerAdmin']
+        }
+      ]
+    },
+    {
+      id: 'appointments',
+      labelKey: 'planning.appointments',
+      icon: 'i-lucide-calendar-check',
+      to: '/appointments',
+      routePrefixes: ['/appointments'],
+      audiences: ['clientAuthenticated']
+    }
+  ],
+  policy: {
+    PROVIDER: { owner: ['manage', 'read'], admin: ['manage', 'read'], member: ['read'] },
+    CLIENT: { owner: ['read'], admin: ['read'], member: ['read'] }
+  }
+}

package/shared/invitation.ts

@@ -0,0 +1,58 @@
+const escape = (value: string) =>
+  value.replace(/\\/g, '\\\\').replace(/\r?\n/g, '\\n').replace(/,/g, '\\,').replace(/;/g, '\\;')
+const stamp = (date: Date) =>
+  date
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}/, '')
+export function calendarInvitation(input: {
+  id: string
+  revision: number
+  title: string
+  start: Date
+  end: Date
+  organizer: string
+  attendee: string
+  url?: string | null
+  cancelled: boolean
+  now?: Date
+}) {
+  const lines = [
+    'BEGIN:VCALENDAR',
+    'VERSION:2.0',
+    'PRODID:-//Nuxt Customer Portal//Planning//EN',
+    `METHOD:${input.cancelled ? 'CANCEL' : 'REQUEST'}`,
+    'BEGIN:VEVENT',
+    `UID:${input.id}@portal-planning`,
+    `SEQUENCE:${input.revision}`,
+    `DTSTAMP:${stamp(input.now || new Date())}`,
+    `DTSTART:${stamp(input.start)}`,
+    `DTEND:${stamp(input.end)}`,
+    `SUMMARY:${escape(input.title)}`,
+    `ORGANIZER:mailto:${input.organizer}`,
+    `ATTENDEE;RSVP=TRUE:mailto:${input.attendee}`,
+    `STATUS:${input.cancelled ? 'CANCELLED' : 'CONFIRMED'}`,
+    ...(input.url ? [`LOCATION:${escape(input.url)}`, `DESCRIPTION:${escape(input.url)}`] : []),
+    'END:VEVENT',
+    'END:VCALENDAR'
+  ]
+  // Fold by UTF-8 bytes, including the continuation space.
+  return (
+    lines
+      .flatMap((line) => {
+        const parts: string[] = []
+        let part = ''
+        for (const char of line) {
+          if (Buffer.byteLength(part + char) > 74) {
+            parts.push(part)
+            part = ' ' + char
+          } else {
+            part += char
+          }
+        }
+        parts.push(part)
+        return parts
+      })
+      .join('\r\n') + '\r\n'
+  )
+}