@btst/stack 5.1.0 → 5.2.0

package/dist/packages/stack/src/plugins/calendar/api/operations.mjs

@@ -0,0 +1,305 @@
+import { defineOperation, OperationHttpError } from '@btst/stack/plugins/api';
+import { z } from 'zod';
+import { calendarPermissions } from '../../../../../../plugins/calendar/permissions.mjs';
+import { listBookingsQuerySchema, createBookingSchema, availabilityQuerySchema, createEventTypeSchema } from '../schemas.mjs';
+import { calculateAvailability, dateInTimezone } from '../scheduling.mjs';
+import { getBookingById, listHostBookings, listEventTypes, getBookingByToken, getEventTypeBySlug, getEventType } from './getters.mjs';
+import { withHostTransaction, cancelBooking, createBooking, deleteEventType, updateEventType, createEventType } from './mutations.mjs';
+
+const hostInput = z.object({ hostId: z.string().min(1).optional() });
+const idInput = z.object({ id: z.string().min(1) });
+const slugInput = z.object({ slug: z.string().min(1) });
+const createEventTypeOperationSchema = createEventTypeSchema.extend({
+  hostId: z.string().min(1).optional()
+});
+const updateEventTypeOperationSchema = idInput.extend({
+  data: createEventTypeSchema
+});
+const availabilityOperationSchema = availabilityQuerySchema.extend({
+  slug: z.string().min(1)
+});
+const createBookingOperationSchema = createBookingSchema.extend({
+  slug: z.string().min(1)
+});
+const tokenInput = z.object({ token: z.string().min(1).max(200) });
+function failure(status, message, code = "CALENDAR_ERROR") {
+  throw new OperationHttpError(status, message, code);
+}
+function resolveHost(context) {
+  if (context.identity) return context.identity.id;
+  if (context.request) return failure(401, "Sign in to manage your calendar");
+  return context.input.hostId ?? failure(400, "Trusted calendar calls require a hostId");
+}
+function requireManagementIdentity(context) {
+  if (context.request && !context.identity)
+    failure(401, "Sign in to manage your calendar");
+}
+async function requireEvent(adapter, id) {
+  return await getEventType(adapter, id) ?? failure(404, "Event type not found");
+}
+async function requirePublicEvent(adapter, slug) {
+  const event = await getEventTypeBySlug(adapter, slug);
+  if (!event?.active) return failure(404, "Event type not found");
+  return event;
+}
+async function requireBooking(adapter, token) {
+  return await getBookingByToken(adapter, token) ?? failure(404, "Booking not found");
+}
+function eventFacts(event) {
+  return { eventTypeId: event.id, hostId: event.hostId };
+}
+function assertHost(event, hostId) {
+  if (event.hostId !== hostId) failure(409, "Event ownership changed");
+}
+async function assertSlugAvailable(adapter, slug, id) {
+  const existing = await getEventTypeBySlug(adapter, slug);
+  if (existing && existing.id !== id)
+    failure(409, "This booking link is already in use");
+}
+function createCalendarOperations(adapter, options) {
+  const cancelled = /* @__PURE__ */ new WeakSet();
+  async function cancelReservation(input, bookingId, hostId) {
+    return withHostTransaction(adapter, hostId, async (tx) => {
+      const booking = await getBookingById(tx, bookingId) ?? failure(404, "Booking not found");
+      if (booking.hostId !== hostId) failure(409, "Booking changed");
+      if (booking.status === "cancelled") return booking;
+      const result = await cancelBooking(tx, booking.id) ?? failure(404, "Booking not found");
+      cancelled.add(input);
+      return result;
+    });
+  }
+  async function afterCancellation(context) {
+    if (cancelled.has(context.input))
+      await options.hooks?.onAfterCancelBooking?.(context.result);
+  }
+  return {
+    listEventTypes: defineOperation({
+      input: hostInput,
+      permission: calendarPermissions.eventType.list,
+      facts: ({ input }) => ({ hostId: input.hostId }),
+      execute: (context) => listEventTypes(adapter, resolveHost(context))
+    }),
+    getEventType: defineOperation({
+      input: idInput,
+      permission: calendarPermissions.eventType.read,
+      facts: async ({ input }) => ({
+        ...eventFacts(await requireEvent(adapter, input.id)),
+        public: false
+      }),
+      before: requireManagementIdentity,
+      execute: ({ input }) => requireEvent(adapter, input.id)
+    }),
+    getPublicEventType: defineOperation({
+      input: slugInput,
+      permission: calendarPermissions.eventType.read,
+      facts: async ({ input }) => ({
+        ...eventFacts(await requirePublicEvent(adapter, input.slug)),
+        public: true
+      }),
+      execute: ({ input }) => requirePublicEvent(adapter, input.slug)
+    }),
+    createEventType: defineOperation({
+      input: createEventTypeOperationSchema,
+      permission: calendarPermissions.eventType.create,
+      facts: ({ input }) => ({ hostId: input.hostId }),
+      execute: (context) => {
+        const hostId = resolveHost(context);
+        return withHostTransaction(adapter, hostId, async (tx) => {
+          await assertSlugAvailable(tx, context.input.slug);
+          return createEventType(
+            tx,
+            hostId,
+            createEventTypeSchema.parse(context.input)
+          );
+        });
+      }
+    }),
+    updateEventType: defineOperation({
+      input: updateEventTypeOperationSchema,
+      permission: calendarPermissions.eventType.update,
+      facts: async ({ input }) => eventFacts(await requireEvent(adapter, input.id)),
+      before: requireManagementIdentity,
+      execute: ({ input, facts }) => withHostTransaction(adapter, facts.hostId, async (tx) => {
+        assertHost(await requireEvent(tx, input.id), facts.hostId);
+        await assertSlugAvailable(tx, input.data.slug, input.id);
+        const bookings = await listHostBookings(tx, facts.hostId);
+        const slotCounts = /* @__PURE__ */ new Map();
+        for (const booking of bookings) {
+          if (booking.eventTypeId !== input.id || booking.status !== "confirmed" || Date.parse(booking.end) <= Date.now())
+            continue;
+          const count = (slotCounts.get(booking.start) ?? 0) + 1;
+          if (count > input.data.capacity)
+            failure(
+              409,
+              "Capacity cannot be lower than existing reservations"
+            );
+          slotCounts.set(booking.start, count);
+        }
+        return await updateEventType(
+          tx,
+          input.id,
+          createEventTypeSchema.parse(input.data)
+        ) ?? failure(404, "Event type not found");
+      })
+    }),
+    deleteEventType: defineOperation({
+      input: idInput,
+      permission: calendarPermissions.eventType.delete,
+      facts: async ({ input }) => eventFacts(await requireEvent(adapter, input.id)),
+      before: requireManagementIdentity,
+      execute: ({ input, facts }) => withHostTransaction(adapter, facts.hostId, async (tx) => {
+        assertHost(await requireEvent(tx, input.id), facts.hostId);
+        const bookings = await listHostBookings(tx, facts.hostId);
+        if (bookings.some(
+          (booking) => booking.eventTypeId === input.id && booking.status === "confirmed" && Date.parse(booking.end) > Date.now()
+        ))
+          failure(
+            409,
+            "Cancel upcoming bookings or deactivate this event type before deleting it"
+          );
+        await deleteEventType(tx, input.id);
+        return { success: true };
+      })
+    }),
+    getAvailability: defineOperation({
+      input: availabilityOperationSchema,
+      permission: calendarPermissions.availability.read,
+      facts: async ({ input }) => eventFacts(await requirePublicEvent(adapter, input.slug)),
+      execute: async ({ input }) => {
+        const event = await requirePublicEvent(adapter, input.slug);
+        return calculateAvailability(
+          event,
+          await listHostBookings(adapter, event.hostId),
+          input.date,
+          input.timezone
+        );
+      }
+    }),
+    createBooking: defineOperation({
+      input: createBookingOperationSchema,
+      permission: calendarPermissions.booking.create,
+      facts: async ({ input }) => eventFacts(await requirePublicEvent(adapter, input.slug)),
+      before: async ({ input }) => options.hooks?.onBeforeCreateBooking?.(input),
+      execute: ({ input, facts }) => withHostTransaction(adapter, facts.hostId, async (tx) => {
+        const event = await requirePublicEvent(tx, input.slug);
+        assertHost(event, facts.hostId);
+        if (event.id !== facts.eventTypeId)
+          failure(409, "Event type changed");
+        const bookings = await listHostBookings(tx, event.hostId);
+        const start = new Date(input.start).toISOString();
+        const availability = calculateAvailability(
+          event,
+          bookings,
+          dateInTimezone(start, input.timezone),
+          input.timezone
+        );
+        const slot = availability.slots.find(
+          (candidate) => candidate.start === start
+        );
+        if (!slot)
+          failure(
+            409,
+            "This time is no longer available",
+            "CALENDAR_SLOT_UNAVAILABLE"
+          );
+        if (bookings.some(
+          (booking) => booking.eventTypeId === event.id && booking.start === start && booking.status === "confirmed" && booking.email === input.email
+        ))
+          failure(409, "This email already has a reservation for this time");
+        return createBooking(tx, {
+          eventTypeId: event.id,
+          hostId: event.hostId,
+          eventName: event.name,
+          start: slot.start,
+          end: slot.end,
+          timezone: input.timezone,
+          name: input.name,
+          email: input.email
+        });
+      }),
+      after: async ({ result }) => options.hooks?.onAfterConfirmBooking?.(result)
+    }),
+    getBooking: defineOperation({
+      input: tokenInput,
+      permission: calendarPermissions.booking.read,
+      facts: async ({ input }) => {
+        const booking = await requireBooking(adapter, input.token);
+        return {
+          bookingId: booking.id,
+          hostId: booking.hostId,
+          tokenValid: true
+        };
+      },
+      execute: ({ input }) => requireBooking(adapter, input.token)
+    }),
+    cancelBooking: defineOperation({
+      input: tokenInput,
+      permission: calendarPermissions.booking.cancel,
+      facts: async ({ input }) => {
+        const booking = await requireBooking(adapter, input.token);
+        return {
+          bookingId: booking.id,
+          hostId: booking.hostId,
+          tokenValid: true
+        };
+      },
+      execute: ({ input, facts }) => cancelReservation(input, facts.bookingId, facts.hostId),
+      after: (context) => afterCancellation(context)
+    }),
+    cancelHostBooking: defineOperation({
+      input: idInput,
+      permission: calendarPermissions.booking.cancel,
+      facts: async ({ input }) => {
+        const booking = await getBookingById(adapter, input.id) ?? failure(404, "Booking not found");
+        return {
+          bookingId: booking.id,
+          hostId: booking.hostId,
+          tokenValid: false
+        };
+      },
+      before: requireManagementIdentity,
+      execute: async ({ input, facts }) => ({
+        ...await cancelReservation(input, facts.bookingId, facts.hostId),
+        cancelToken: ""
+      }),
+      after: (context) => afterCancellation(context)
+    }),
+    listBookings: defineOperation({
+      input: listBookingsQuerySchema.extend({
+        hostId: z.string().min(1).optional()
+      }),
+      permission: calendarPermissions.booking.list,
+      facts: ({ input }) => ({ hostId: input.hostId }),
+      execute: async (context) => {
+        const bookings = await listHostBookings(adapter, resolveHost(context));
+        return bookings.filter((booking) => {
+          if (context.input.eventTypeId && booking.eventTypeId !== context.input.eventTypeId)
+            return false;
+          if (context.input.period === "upcoming")
+            return Date.parse(booking.end) > Date.now();
+          if (context.input.period === "past")
+            return Date.parse(booking.end) <= Date.now();
+          return true;
+        }).sort((a, b) => a.start.localeCompare(b.start)).map((booking) => ({ ...booking, cancelToken: "" }));
+      }
+    }),
+    remindBooking: defineOperation({
+      input: idInput,
+      permission: calendarPermissions.booking.remind,
+      facts: async ({ input }) => {
+        const booking = await getBookingById(adapter, input.id) ?? failure(404, "Booking not found");
+        return { bookingId: booking.id, hostId: booking.hostId };
+      },
+      execute: async ({ input, facts }) => {
+        const booking = await getBookingById(adapter, input.id) ?? failure(404, "Booking not found");
+        if (booking.hostId !== facts.hostId || booking.status !== "confirmed" || Date.parse(booking.start) <= Date.now())
+          failure(409, "Only upcoming confirmed bookings can be reminded");
+        await options.hooks?.onBeforeRemindBooking?.(booking);
+        return booking;
+      },
+      after: async ({ result }) => options.hooks?.onAfterRemindBooking?.(result)
+    })
+  };
+}
+
+export { availabilityOperationSchema, createBookingOperationSchema, createCalendarOperations, createEventTypeOperationSchema, updateEventTypeOperationSchema };

package/dist/packages/stack/src/plugins/calendar/api/plugin.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const db = require('../db.cjs');
+const schemas = require('../schemas.cjs');
+const operations = require('./operations.cjs');
+
+const calendarBackendPlugin = (options = {}) => api.defineBackendPlugin({
+  id: "calendar",
+  dbPlugin: db.calendarSchema,
+  operations: (adapter) => operations.createCalendarOperations(adapter, options),
+  routes: (_adapter, _context, operations) => ({
+    listEventTypes: api.createEndpoint(
+      "/calendar/events",
+      { method: "GET", requireRequest: true },
+      operations.listEventTypes.route(() => ({}))
+    ),
+    getEventType: api.createEndpoint(
+      "/calendar/events/:id",
+      { method: "GET", requireRequest: true },
+      operations.getEventType.route((ctx) => ({ id: ctx.params.id }))
+    ),
+    createEventType: api.createEndpoint(
+      "/calendar/events",
+      { method: "POST", body: schemas.createEventTypeSchema, requireRequest: true },
+      operations.createEventType.route((ctx) => ctx.body)
+    ),
+    updateEventType: api.createEndpoint(
+      "/calendar/events/:id",
+      { method: "PATCH", body: schemas.createEventTypeSchema, requireRequest: true },
+      operations.updateEventType.route((ctx) => ({
+        id: ctx.params.id,
+        data: ctx.body
+      }))
+    ),
+    deleteEventType: api.createEndpoint(
+      "/calendar/events/:id",
+      { method: "DELETE", requireRequest: true },
+      operations.deleteEventType.route((ctx) => ({ id: ctx.params.id }))
+    ),
+    getPublicEventType: api.createEndpoint(
+      "/calendar/book/:slug",
+      { method: "GET", requireRequest: true },
+      operations.getPublicEventType.route((ctx) => ({
+        slug: ctx.params.slug
+      }))
+    ),
+    getAvailability: api.createEndpoint(
+      "/calendar/book/:slug/slots",
+      { method: "GET", query: schemas.availabilityQuerySchema, requireRequest: true },
+      operations.getAvailability.route((ctx) => ({
+        slug: ctx.params.slug,
+        ...ctx.query
+      }))
+    ),
+    createBooking: api.createEndpoint(
+      "/calendar/book/:slug",
+      { method: "POST", body: schemas.createBookingSchema, requireRequest: true },
+      operations.createBooking.route((ctx) => ({
+        slug: ctx.params.slug,
+        ...ctx.body
+      }))
+    ),
+    getBooking: api.createEndpoint(
+      "/calendar/cancel/:token",
+      { method: "GET", requireRequest: true },
+      operations.getBooking.route((ctx) => ({ token: ctx.params.token }))
+    ),
+    cancelBooking: api.createEndpoint(
+      "/calendar/cancel/:token",
+      { method: "POST", requireRequest: true },
+      operations.cancelBooking.route((ctx) => ({ token: ctx.params.token }))
+    ),
+    cancelHostBooking: api.createEndpoint(
+      "/calendar/bookings/:id/cancel",
+      { method: "POST", requireRequest: true },
+      operations.cancelHostBooking.route((ctx) => ({ id: ctx.params.id }))
+    ),
+    listBookings: api.createEndpoint(
+      "/calendar/bookings",
+      { method: "GET", query: schemas.listBookingsQuerySchema, requireRequest: true },
+      operations.listBookings.route((ctx) => ctx.query)
+    )
+  })
+});
+
+exports.calendarBackendPlugin = calendarBackendPlugin;

package/dist/packages/stack/src/plugins/calendar/api/plugin.mjs

@@ -0,0 +1,85 @@
+import { defineBackendPlugin, createEndpoint } from '@btst/stack/plugins/api';
+import { calendarSchema } from '../db.mjs';
+import { listBookingsQuerySchema, createBookingSchema, availabilityQuerySchema, createEventTypeSchema } from '../schemas.mjs';
+import { createCalendarOperations } from './operations.mjs';
+
+const calendarBackendPlugin = (options = {}) => defineBackendPlugin({
+  id: "calendar",
+  dbPlugin: calendarSchema,
+  operations: (adapter) => createCalendarOperations(adapter, options),
+  routes: (_adapter, _context, operations) => ({
+    listEventTypes: createEndpoint(
+      "/calendar/events",
+      { method: "GET", requireRequest: true },
+      operations.listEventTypes.route(() => ({}))
+    ),
+    getEventType: createEndpoint(
+      "/calendar/events/:id",
+      { method: "GET", requireRequest: true },
+      operations.getEventType.route((ctx) => ({ id: ctx.params.id }))
+    ),
+    createEventType: createEndpoint(
+      "/calendar/events",
+      { method: "POST", body: createEventTypeSchema, requireRequest: true },
+      operations.createEventType.route((ctx) => ctx.body)
+    ),
+    updateEventType: createEndpoint(
+      "/calendar/events/:id",
+      { method: "PATCH", body: createEventTypeSchema, requireRequest: true },
+      operations.updateEventType.route((ctx) => ({
+        id: ctx.params.id,
+        data: ctx.body
+      }))
+    ),
+    deleteEventType: createEndpoint(
+      "/calendar/events/:id",
+      { method: "DELETE", requireRequest: true },
+      operations.deleteEventType.route((ctx) => ({ id: ctx.params.id }))
+    ),
+    getPublicEventType: createEndpoint(
+      "/calendar/book/:slug",
+      { method: "GET", requireRequest: true },
+      operations.getPublicEventType.route((ctx) => ({
+        slug: ctx.params.slug
+      }))
+    ),
+    getAvailability: createEndpoint(
+      "/calendar/book/:slug/slots",
+      { method: "GET", query: availabilityQuerySchema, requireRequest: true },
+      operations.getAvailability.route((ctx) => ({
+        slug: ctx.params.slug,
+        ...ctx.query
+      }))
+    ),
+    createBooking: createEndpoint(
+      "/calendar/book/:slug",
+      { method: "POST", body: createBookingSchema, requireRequest: true },
+      operations.createBooking.route((ctx) => ({
+        slug: ctx.params.slug,
+        ...ctx.body
+      }))
+    ),
+    getBooking: createEndpoint(
+      "/calendar/cancel/:token",
+      { method: "GET", requireRequest: true },
+      operations.getBooking.route((ctx) => ({ token: ctx.params.token }))
+    ),
+    cancelBooking: createEndpoint(
+      "/calendar/cancel/:token",
+      { method: "POST", requireRequest: true },
+      operations.cancelBooking.route((ctx) => ({ token: ctx.params.token }))
+    ),
+    cancelHostBooking: createEndpoint(
+      "/calendar/bookings/:id/cancel",
+      { method: "POST", requireRequest: true },
+      operations.cancelHostBooking.route((ctx) => ({ id: ctx.params.id }))
+    ),
+    listBookings: createEndpoint(
+      "/calendar/bookings",
+      { method: "GET", query: listBookingsQuerySchema, requireRequest: true },
+      operations.listBookings.route((ctx) => ctx.query)
+    )
+  })
+});
+
+export { calendarBackendPlugin };