@medalsocial/booking 0.0.0-placeholder.0 → 0.2.0

package/dist/next/catalogue.d.mts

@@ -0,0 +1,38 @@
+import { BookingConfig } from "../core/config.mjs";
+import { MedalResource, MedalScheduleDay, MedalService, MedalSlot } from "../core/wire.mjs";
+import { MedalSeam, RangeArgs } from "./medal.mjs";
+import { BookingCacheAdapter, BookingLogger } from "./options.mjs";
+//#region src/next/catalogue.d.ts
+export declare const CATALOGUE_TAG = "booking-catalogue";
+/** `{ fresh: true }` skips the cache for one read and writes no entry. Server
+ * callers only — the create route's live re-read after a `slotTaken`; no
+ * route lets a visitor ask for it. */
+export interface ReadOptions {
+  fresh?: boolean;
+}
+export declare function slotsTag(serviceId: string): string;
+/**
+ * Where a slot key starts: the later of the caller's `from` and now, floored to
+ * 30 s. Unrounded, no two visitors would share an entry; not clamped to now,
+ * any past instant would be a key of its own.
+ */
+export declare function slotKeyStart(fromTs: number, now?: number): number;
+export interface Catalogue {
+  cachedServices(): Promise<MedalService[]>;
+  cachedResources(): Promise<MedalResource[]>;
+  cachedSchedule(args: RangeArgs): Promise<MedalScheduleDay[]>;
+  cachedAvailability(args: RangeArgs, options?: ReadOptions): Promise<MedalSlot[]>;
+  expireSlots(serviceIds: Iterable<string>): void;
+}
+export interface CatalogueOptions {
+  config: Pick<BookingConfig, 'timeZone' | 'locale' | 'dayparts'>;
+  cache: {
+    data: BookingCacheAdapter;
+    prefix: string;
+  };
+  logger: BookingLogger;
+}
+type Seam = Pick<MedalSeam, 'listServices' | 'listResources' | 'listAvailability' | 'listSchedule'>;
+export declare function createCatalogue(options: CatalogueOptions, medal: Seam): Catalogue;
+//#endregion
+//# sourceMappingURL=catalogue.d.mts.map

package/dist/next/catalogue.mjs

@@ -0,0 +1,215 @@
+import { createClock } from "../core/clock.mjs";
+import { visitKeyOfIds } from "../core/visit.mjs";
+import { cacheLoad } from "./options.mjs";
+//#region src/next/catalogue.ts
+/**
+* A short-lived data cache in front of Medal's booking READS (the L2 cache).
+*
+* The booking page and the wizard's route handlers would otherwise ask Medal
+* live on every request, which is most of a one-second TTFB and most of the
+* wait after a service tap. It reads through `options.cache.data`: with the
+* `next-data` adapter that is `unstable_cache` (on OpenNext, the incremental
+* cache — R2 plus the Durable Object tag cache), shared across isolates and
+* visitors.
+*
+* `unstable_cache` is stale-while-revalidate: an expired entry is served once
+* more while it refills. So every key also carries TIME — the slot key a 30 s
+* bucket, the catalogue keys a five-minute one — and a key that has moved on
+* is a miss, not a stale hit. The resulting bounds:
+*
+* - free slots (tag `booking-slots:<serviceId>`, one per service in the
+*   visit): at most ~60 s old. The
+*   site's own create / move / cancel expire the tag at once (`expireSlots`);
+*   the bound is what covers a booking made anywhere else;
+* - the catalogue (services, stylists, opening hours; tag `booking-catalogue`):
+*   at most ~10 min old.
+*
+* KEYS. Every entry is keyed `[prefix, '<read>']` plus its arguments, the
+* scheme the first site on this package already uses, so its key parts stay
+* the same when `prefix` does. A slot or schedule key names the VISIT
+* (`visitKeyOfIds`: `a+b` for a person having both, the bare id for one
+* service), so a one-service key is byte-identical to what it was before
+* visits existed and a deploy does not empty the cache.
+*
+* A failed read throws and is not cached, so a Medal blip is not pinned.
+*/
+const CATALOGUE_TAG = "booking-catalogue";
+const CATALOGUE_TTL_S = 300;
+const SLOTS_TTL_S = 30;
+/** The slot key step, and the catalogue's time bucket. */
+const SLOT_KEY_STEP_MS = 3e4;
+const CATALOGUE_BUCKET_MS = 3e5;
+/** How far ahead a cached read may reach; beyond it the read is live. Matches
+* the 62-day range bound the routes put on a query string. */
+const MAX_KEY_AHEAD_MS = 53568e5;
+function slotsTag(serviceId) {
+	return `booking-slots:${serviceId}`;
+}
+/**
+* Where a slot key starts: the later of the caller's `from` and now, floored to
+* 30 s. Unrounded, no two visitors would share an entry; not clamped to now,
+* any past instant would be a key of its own.
+*/
+function slotKeyStart(fromTs, now = Date.now()) {
+	return Math.floor(Math.max(fromTs, now) / SLOT_KEY_STEP_MS) * SLOT_KEY_STEP_MS;
+}
+/** Every service in the read's visit, the first one first. */
+function visitIdsOf(args) {
+	return [args.serviceId, ...args.extraServiceIds ?? []];
+}
+/** `extraServiceIds` as a spread: absent for a one-service visit, so a
+* one-service read reaches the seam with exactly the arguments it always had. */
+function extrasOf(args) {
+	return args.extraServiceIds?.length ? { extraServiceIds: args.extraServiceIds } : {};
+}
+function catalogueBucket(now) {
+	return Math.floor(now / CATALOGUE_BUCKET_MS);
+}
+function createCatalogue(options, medal) {
+	const { data } = options.cache;
+	const KEY_PREFIX = options.cache.prefix;
+	const clock = createClock(options.config);
+	/** `ts` if it is a local midnight, otherwise the next one. */
+	function roundUpToDay(ts) {
+		return clock.dayStart(ts) === ts ? ts : clock.dayStart(ts, 1);
+	}
+	/**
+	* The range a read is CACHED under, or `null` for a read that must go live.
+	*
+	* The range comes from a visitor's query string, so the key is normalised to
+	* a small set of values — otherwise every distinct `from_ts`/`to_ts` would be
+	* a Medal call and a cache write:
+	*
+	* - `from` is `slotKeyStart` (the later of it and now, floored to 30 s);
+	* - `to` rounded UP to a local midnight — the booking page's window already
+	*   ends on one, so it is unchanged there;
+	* - a key reaching more than 62 days ahead is not cached at all;
+	* - a stylist-narrowed read (the manage page's) is not cached at all.
+	*
+	* The caller's real bounds are applied to the answer afterwards.
+	*/
+	function keyRange(args, now) {
+		if (args.resourceId) return null;
+		const fromTs = slotKeyStart(args.fromTs, now);
+		const toTs = roundUpToDay(args.toTs);
+		const limit = now + MAX_KEY_AHEAD_MS;
+		if (fromTs > limit || toTs > limit || toTs <= fromTs) return null;
+		return {
+			fromTs,
+			toTs
+		};
+	}
+	function cachedServices() {
+		return cacheLoad(data, [KEY_PREFIX, "services"], [catalogueBucket(Date.now())], () => medal.listServices(), {
+			ttlSeconds: CATALOGUE_TTL_S,
+			tags: [CATALOGUE_TAG]
+		});
+	}
+	function cachedResources() {
+		return cacheLoad(data, [KEY_PREFIX, "resources"], [catalogueBucket(Date.now())], () => medal.listResources(), {
+			ttlSeconds: CATALOGUE_TTL_S,
+			tags: [CATALOGUE_TAG]
+		});
+	}
+	/**
+	* Opening hours per service (the cutoffs are per service) over a range.
+	*
+	* The key range can end after the one asked about, so dates outside the
+	* caller's real range are dropped.
+	*/
+	async function cachedSchedule(args) {
+		const now = Date.now();
+		const key = keyRange(args, now);
+		if (key === null) return medal.listSchedule(args);
+		const { serviceId } = args;
+		const days = await cacheLoad(data, [KEY_PREFIX, "schedule"], [
+			visitKeyOfIds(visitIdsOf(args)),
+			key.fromTs,
+			key.toTs,
+			catalogueBucket(now)
+		], () => medal.listSchedule({
+			serviceId,
+			...extrasOf(args),
+			fromTs: key.fromTs,
+			toTs: key.toTs
+		}), {
+			ttlSeconds: CATALOGUE_TTL_S,
+			tags: [CATALOGUE_TAG]
+		});
+		const firstDay = clock.dayKey(args.fromTs);
+		const lastDay = clock.dayKey(args.toTs - 1);
+		return days.filter((day) => day.date === null || day.date >= firstDay && day.date <= lastDay);
+	}
+	/**
+	* Free slots for one visit — one service, or one person's several back to
+	* back. The entry carries the tag of EVERY service in the visit, so a write
+	* to any one of them (`expireSlots`) retires it; the key is the same for
+	* every call with the same arguments.
+	*
+	* Only slots starting inside the caller's real `[fromTs, toTs)` AND not
+	* before now are returned: the key reaches forward to the next local
+	* midnight, and an entry up to a minute old may still hold a slot that has
+	* since started.
+	*/
+	async function cachedAvailability(args, readOptions = {}) {
+		const now = Date.now();
+		const key = readOptions.fresh ? null : keyRange(args, now);
+		let slots;
+		if (key === null) slots = await medal.listAvailability(args);
+		else {
+			const { serviceId } = args;
+			slots = await cacheLoad(data, [KEY_PREFIX, "availability"], [
+				visitKeyOfIds(visitIdsOf(args)),
+				key.fromTs,
+				key.toTs,
+				Math.floor(now / SLOT_KEY_STEP_MS)
+			], () => medal.listAvailability({
+				serviceId,
+				...extrasOf(args),
+				fromTs: key.fromTs,
+				toTs: key.toTs
+			}), {
+				ttlSeconds: SLOTS_TTL_S,
+				tags: [...new Set(visitIdsOf(args))].map(slotsTag)
+			});
+		}
+		const earliest = Math.max(args.fromTs, now);
+		return slots.filter((slot) => {
+			if (slot.start_ts === null) return true;
+			const startTs = Date.parse(slot.start_ts);
+			return !Number.isFinite(startTs) || startTs >= earliest && startTs < args.toTs;
+		});
+	}
+	/**
+	* Expire the cached slots of every service a write just touched, so the next
+	* read — this visitor's confirmation, the next visitor's time step — is live.
+	*
+	* Best effort: the write has already happened, and a cache that could not be
+	* expired must not turn a made booking into an error. The ~60 s bound above
+	* is the backstop.
+	*/
+	function expireSlots(serviceIds) {
+		for (const serviceId of new Set(serviceIds)) {
+			const warn = (error) => options.logger.warn({
+				err: error,
+				serviceId
+			}, "Could not expire cached booking slots");
+			try {
+				data.expireTag?.(slotsTag(serviceId))?.catch(warn);
+			} catch (error) {
+				warn(error);
+			}
+		}
+	}
+	return {
+		cachedServices,
+		cachedResources,
+		cachedSchedule,
+		cachedAvailability,
+		expireSlots
+	};
+}
+//#endregion
+export { CATALOGUE_TAG, createCatalogue, slotKeyStart, slotsTag };
+
+//# sourceMappingURL=catalogue.mjs.map

package/dist/next/catalogue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalogue.mjs","names":[],"sources":["../../src/next/catalogue.ts"],"sourcesContent":["/**\n * A short-lived data cache in front of Medal's booking READS (the L2 cache).\n *\n * The booking page and the wizard's route handlers would otherwise ask Medal\n * live on every request, which is most of a one-second TTFB and most of the\n * wait after a service tap. It reads through `options.cache.data`: with the\n * `next-data` adapter that is `unstable_cache` (on OpenNext, the incremental\n * cache — R2 plus the Durable Object tag cache), shared across isolates and\n * visitors.\n *\n * `unstable_cache` is stale-while-revalidate: an expired entry is served once\n * more while it refills. So every key also carries TIME — the slot key a 30 s\n * bucket, the catalogue keys a five-minute one — and a key that has moved on\n * is a miss, not a stale hit. The resulting bounds:\n *\n * - free slots (tag `booking-slots:<serviceId>`, one per service in the\n *   visit): at most ~60 s old. The\n *   site's own create / move / cancel expire the tag at once (`expireSlots`);\n *   the bound is what covers a booking made anywhere else;\n * - the catalogue (services, stylists, opening hours; tag `booking-catalogue`):\n *   at most ~10 min old.\n *\n * KEYS. Every entry is keyed `[prefix, '<read>']` plus its arguments, the\n * scheme the first site on this package already uses, so its key parts stay\n * the same when `prefix` does. A slot or schedule key names the VISIT\n * (`visitKeyOfIds`: `a+b` for a person having both, the bare id for one\n * service), so a one-service key is byte-identical to what it was before\n * visits existed and a deploy does not empty the cache.\n *\n * A failed read throws and is not cached, so a Medal blip is not pinned.\n */\n\nimport { createClock } from '../core/clock';\nimport type { BookingConfig } from '../core/config';\nimport { visitKeyOfIds } from '../core/visit';\nimport type { MedalResource, MedalScheduleDay, MedalService, MedalSlot } from '../core/wire';\nimport type { MedalSeam, RangeArgs } from './medal';\nimport { type BookingCacheAdapter, type BookingLogger, cacheLoad } from './options';\n\nexport const CATALOGUE_TAG = 'booking-catalogue';\nconst CATALOGUE_TTL_S = 300;\nconst SLOTS_TTL_S = 30;\n\n/** The slot key step, and the catalogue's time bucket. */\nconst SLOT_KEY_STEP_MS = 30 * 1000;\nconst CATALOGUE_BUCKET_MS = 5 * 60 * 1000;\n\n/** How far ahead a cached read may reach; beyond it the read is live. Matches\n * the 62-day range bound the routes put on a query string. */\nconst MAX_KEY_AHEAD_MS = 62 * 24 * 60 * 60 * 1000;\n\n/** `{ fresh: true }` skips the cache for one read and writes no entry. Server\n * callers only — the create route's live re-read after a `slotTaken`; no\n * route lets a visitor ask for it. */\nexport interface ReadOptions {\n  fresh?: boolean;\n}\n\nexport function slotsTag(serviceId: string): string {\n  return `booking-slots:${serviceId}`;\n}\n\n/**\n * Where a slot key starts: the later of the caller's `from` and now, floored to\n * 30 s. Unrounded, no two visitors would share an entry; not clamped to now,\n * any past instant would be a key of its own.\n */\nexport function slotKeyStart(fromTs: number, now: number = Date.now()): number {\n  return Math.floor(Math.max(fromTs, now) / SLOT_KEY_STEP_MS) * SLOT_KEY_STEP_MS;\n}\n\n/** Every service in the read's visit, the first one first. */\nfunction visitIdsOf(args: RangeArgs): string[] {\n  return [args.serviceId, ...(args.extraServiceIds ?? [])];\n}\n\n/** `extraServiceIds` as a spread: absent for a one-service visit, so a\n * one-service read reaches the seam with exactly the arguments it always had. */\nfunction extrasOf(args: RangeArgs): Pick<RangeArgs, 'extraServiceIds'> {\n  return args.extraServiceIds?.length ? { extraServiceIds: args.extraServiceIds } : {};\n}\n\nfunction catalogueBucket(now: number): number {\n  return Math.floor(now / CATALOGUE_BUCKET_MS);\n}\n\nexport interface Catalogue {\n  cachedServices(): Promise<MedalService[]>;\n  cachedResources(): Promise<MedalResource[]>;\n  cachedSchedule(args: RangeArgs): Promise<MedalScheduleDay[]>;\n  cachedAvailability(args: RangeArgs, options?: ReadOptions): Promise<MedalSlot[]>;\n  expireSlots(serviceIds: Iterable<string>): void;\n}\n\nexport interface CatalogueOptions {\n  config: Pick<BookingConfig, 'timeZone' | 'locale' | 'dayparts'>;\n  cache: { data: BookingCacheAdapter; prefix: string };\n  logger: BookingLogger;\n}\n\ntype Seam = Pick<MedalSeam, 'listServices' | 'listResources' | 'listAvailability' | 'listSchedule'>;\n\nexport function createCatalogue(options: CatalogueOptions, medal: Seam): Catalogue {\n  const { data } = options.cache;\n  const KEY_PREFIX = options.cache.prefix;\n  const clock = createClock(options.config);\n\n  /** `ts` if it is a local midnight, otherwise the next one. */\n  function roundUpToDay(ts: number): number {\n    const start = clock.dayStart(ts);\n    return start === ts ? ts : clock.dayStart(ts, 1);\n  }\n\n  /**\n   * The range a read is CACHED under, or `null` for a read that must go live.\n   *\n   * The range comes from a visitor's query string, so the key is normalised to\n   * a small set of values — otherwise every distinct `from_ts`/`to_ts` would be\n   * a Medal call and a cache write:\n   *\n   * - `from` is `slotKeyStart` (the later of it and now, floored to 30 s);\n   * - `to` rounded UP to a local midnight — the booking page's window already\n   *   ends on one, so it is unchanged there;\n   * - a key reaching more than 62 days ahead is not cached at all;\n   * - a stylist-narrowed read (the manage page's) is not cached at all.\n   *\n   * The caller's real bounds are applied to the answer afterwards.\n   */\n  function keyRange(args: RangeArgs, now: number): { fromTs: number; toTs: number } | null {\n    if (args.resourceId) return null;\n    const fromTs = slotKeyStart(args.fromTs, now);\n    const toTs = roundUpToDay(args.toTs);\n    const limit = now + MAX_KEY_AHEAD_MS;\n    if (fromTs > limit || toTs > limit || toTs <= fromTs) return null;\n    return { fromTs, toTs };\n  }\n\n  function cachedServices(): Promise<MedalService[]> {\n    return cacheLoad(\n      data,\n      [KEY_PREFIX, 'services'],\n      [catalogueBucket(Date.now())],\n      () => medal.listServices(),\n      {\n        ttlSeconds: CATALOGUE_TTL_S,\n        tags: [CATALOGUE_TAG],\n      }\n    );\n  }\n\n  function cachedResources(): Promise<MedalResource[]> {\n    return cacheLoad(\n      data,\n      [KEY_PREFIX, 'resources'],\n      [catalogueBucket(Date.now())],\n      () => medal.listResources(),\n      { ttlSeconds: CATALOGUE_TTL_S, tags: [CATALOGUE_TAG] }\n    );\n  }\n\n  /**\n   * Opening hours per service (the cutoffs are per service) over a range.\n   *\n   * The key range can end after the one asked about, so dates outside the\n   * caller's real range are dropped.\n   */\n  async function cachedSchedule(args: RangeArgs): Promise<MedalScheduleDay[]> {\n    const now = Date.now();\n    const key = keyRange(args, now);\n    if (key === null) return medal.listSchedule(args);\n    const { serviceId } = args;\n    const days = await cacheLoad(\n      data,\n      [KEY_PREFIX, 'schedule'],\n      // The visit, not the first service: a visit's last start is earlier than\n      // its first service's alone, so the two answers are different entries.\n      [visitKeyOfIds(visitIdsOf(args)), key.fromTs, key.toTs, catalogueBucket(now)],\n      () =>\n        medal.listSchedule({ serviceId, ...extrasOf(args), fromTs: key.fromTs, toTs: key.toTs }),\n      { ttlSeconds: CATALOGUE_TTL_S, tags: [CATALOGUE_TAG] }\n    );\n    const firstDay = clock.dayKey(args.fromTs);\n    // The local day holding the last instant before `toTs` is the last one\n    // asked about; a day starting at or after `toTs` was not.\n    const lastDay = clock.dayKey(args.toTs - 1);\n    // `date` is ISO `YYYY-MM-DD`, so string order is date order. A null date is\n    // left for `toBookingDayDto`, which already drops it.\n    return days.filter((day) => day.date === null || (day.date >= firstDay && day.date <= lastDay));\n  }\n\n  /**\n   * Free slots for one visit — one service, or one person's several back to\n   * back. The entry carries the tag of EVERY service in the visit, so a write\n   * to any one of them (`expireSlots`) retires it; the key is the same for\n   * every call with the same arguments.\n   *\n   * Only slots starting inside the caller's real `[fromTs, toTs)` AND not\n   * before now are returned: the key reaches forward to the next local\n   * midnight, and an entry up to a minute old may still hold a slot that has\n   * since started.\n   */\n  async function cachedAvailability(\n    args: RangeArgs,\n    readOptions: ReadOptions = {}\n  ): Promise<MedalSlot[]> {\n    const now = Date.now();\n    const key = readOptions.fresh ? null : keyRange(args, now);\n    let slots: MedalSlot[];\n    if (key === null) {\n      slots = await medal.listAvailability(args);\n    } else {\n      const { serviceId } = args;\n      // The time bucket as well as the start: a FUTURE `from` (the manage\n      // page's) keys a start that never moves, and the bucket still retires it.\n      slots = await cacheLoad(\n        data,\n        [KEY_PREFIX, 'availability'],\n        [visitKeyOfIds(visitIdsOf(args)), key.fromTs, key.toTs, Math.floor(now / SLOT_KEY_STEP_MS)],\n        () =>\n          medal.listAvailability({\n            serviceId,\n            ...extrasOf(args),\n            fromTs: key.fromTs,\n            toTs: key.toTs,\n          }),\n        { ttlSeconds: SLOTS_TTL_S, tags: [...new Set(visitIdsOf(args))].map(slotsTag) }\n      );\n    }\n    const earliest = Math.max(args.fromTs, now);\n    return slots.filter((slot) => {\n      // Unreadable starts are kept for `toBookingSlotDto`, which drops them.\n      if (slot.start_ts === null) return true;\n      const startTs = Date.parse(slot.start_ts);\n      return !Number.isFinite(startTs) || (startTs >= earliest && startTs < args.toTs);\n    });\n  }\n\n  /**\n   * Expire the cached slots of every service a write just touched, so the next\n   * read — this visitor's confirmation, the next visitor's time step — is live.\n   *\n   * Best effort: the write has already happened, and a cache that could not be\n   * expired must not turn a made booking into an error. The ~60 s bound above\n   * is the backstop.\n   */\n  function expireSlots(serviceIds: Iterable<string>): void {\n    for (const serviceId of new Set(serviceIds)) {\n      const warn = (error: unknown) =>\n        options.logger.warn({ err: error, serviceId }, 'Could not expire cached booking slots');\n      try {\n        data.expireTag?.(slotsTag(serviceId))?.catch(warn);\n      } catch (error) {\n        warn(error);\n      }\n    }\n  }\n\n  return { cachedServices, cachedResources, cachedSchedule, cachedAvailability, expireSlots };\n}\n"],"mappings":"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"}

package/dist/next/handler.d.mts

@@ -0,0 +1,11 @@
+import { BookingRuntime } from "./runtime.mjs";
+//#region src/next/handler.d.ts
+export interface BookingHandler {
+  GET(request: Request): Promise<Response>;
+  POST(request: Request): Promise<Response>;
+  DELETE(request: Request): Promise<Response>;
+}
+/** The handler over an existing runtime (what `createBookingServer` shares). */
+export declare function createBookingHandlerFor(rt: BookingRuntime): BookingHandler;
+//#endregion
+//# sourceMappingURL=handler.d.mts.map

package/dist/next/handler.mjs

@@ -0,0 +1,150 @@
+import { bookingErrorResponse } from "./routes/shared.mjs";
+import { availabilityRoute, avatarRoute, nextFreeRoute, resourcesRoute, scheduleRoute, servicesRoute } from "./routes/catalogue-routes.mjs";
+import { createRoute } from "./routes/create.mjs";
+import { manageRoute, manageSummaryRoute } from "./routes/manage.mjs";
+import { loginVerifyRoute, personsRoute, sessionExpiredRoute, sessionTouchRoute, vippsFlashRoute, vippsLinkVerifyRoute } from "./routes/portal-routes.mjs";
+import { NextResponse } from "next/server";
+//#region src/next/handler.ts
+/**
+* One drop-in handler for every booking and portal API route.
+*
+* An app mounts it on two catch-alls and is done:
+*
+* ```ts
+* // app/api/booking/[...path]/route.ts and app/api/portal/[...path]/route.ts
+* export const { GET, POST, DELETE } = booking.handler;
+* ```
+*
+* It dispatches on the path after `config.paths.api` / `config.paths.portalApi`:
+*
+* | Path (after the prefix) | Methods |
+* |---|---|
+* | `services`, `resources`, `availability`, `schedule`, `next-free` | GET |
+* | `avatar/<resourceId>` | GET |
+* | `create` | POST |
+* | `manage/<token>` | GET (the booking), POST (`cancel` / `reschedule`) |
+* | portal `login/verify`, `persons`, `session/touch`, `vipps/link/verify` | POST |
+* | portal `session/expired` | GET |
+* | portal `vipps/flash` | DELETE |
+*
+* Static routes in the app still win over the catch-all in Next, so a site
+* keeps any route of its own beside these.
+*/
+const BOOKING_ROUTES = {
+	services: { GET: (rt) => servicesRoute(rt) },
+	resources: { GET: (rt, request) => resourcesRoute(rt, request) },
+	availability: { GET: (rt, request) => availabilityRoute(rt, request) },
+	schedule: { GET: (rt, request) => scheduleRoute(rt, request) },
+	"next-free": { GET: (rt) => nextFreeRoute(rt) },
+	create: { POST: (rt, request) => createRoute(rt, request) }
+};
+const BOOKING_PARAM_ROUTES = {
+	avatar: { GET: (rt, request, segment) => avatarRoute(rt, request, segment) },
+	manage: {
+		GET: (rt, request, segment) => manageSummaryRoute(rt, request, segment),
+		POST: (rt, request, segment) => manageRoute(rt, request, segment)
+	}
+};
+const PORTAL_ROUTES = {
+	"login/verify": { POST: (rt, request) => loginVerifyRoute(rt, request) },
+	persons: { POST: (rt, request) => personsRoute(rt, request) },
+	"session/touch": { POST: (rt) => sessionTouchRoute(rt) },
+	"session/expired": { GET: (rt, request) => sessionExpiredRoute(rt, request) },
+	"vipps/flash": { DELETE: (rt, request) => vippsFlashRoute(rt, request) },
+	"vipps/link/verify": { POST: (rt, request) => vippsLinkVerifyRoute(rt, request) }
+};
+/** The rest of `pathname` after `prefix`, or `null` when it is not under it. */
+function under(pathname, prefix) {
+	const base = prefix.replace(/\/+$/, "");
+	if (!pathname.startsWith(`${base}/`)) return null;
+	return pathname.slice(base.length + 1).replace(/\/+$/, "");
+}
+function decoded(segment) {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return null;
+	}
+}
+function matchBooking(rest) {
+	const fixed = BOOKING_ROUTES[rest];
+	if (fixed) return {
+		scope: `booking/${rest}`,
+		routes: fixed,
+		segment: ""
+	};
+	const slash = rest.indexOf("/");
+	if (slash > 0) {
+		const head = rest.slice(0, slash);
+		const tail = rest.slice(slash + 1);
+		const routes = BOOKING_PARAM_ROUTES[head];
+		if (routes && tail !== "" && !tail.includes("/")) {
+			const segment = decoded(tail);
+			if (segment === null) return "malformed";
+			return {
+				scope: `booking/${head}`,
+				routes,
+				segment
+			};
+		}
+	}
+	return null;
+}
+function matchPortal(rest) {
+	const routes = PORTAL_ROUTES[rest];
+	return routes ? {
+		scope: `portal/${rest}`,
+		routes,
+		segment: ""
+	} : null;
+}
+/**
+* The route a path names. The LONGER prefix is tried first, so a portal API
+* nested under the booking API (`/api` and `/api/portal`) still reaches the
+* portal routes, and the other way round.
+*/
+function match(rt, pathname) {
+	const { api, portalApi } = rt.config.paths;
+	const prefixes = [{
+		prefix: api,
+		find: matchBooking
+	}, {
+		prefix: portalApi,
+		find: matchPortal
+	}].sort((a, b) => b.prefix.replace(/\/+$/, "").length - a.prefix.replace(/\/+$/, "").length);
+	for (const { prefix, find } of prefixes) {
+		const rest = under(pathname, prefix);
+		if (rest === null) continue;
+		const found = find(rest);
+		if (found !== null) return found;
+	}
+	return null;
+}
+/** The handler over an existing runtime (what `createBookingServer` shares). */
+function createBookingHandlerFor(rt) {
+	async function handle(method, request) {
+		const found = match(rt, new URL(request.url).pathname);
+		if (found === "malformed") return bookingErrorResponse("invalidInput", 400, "path is malformed");
+		if (found === null) return bookingErrorResponse("notFound", 404);
+		const route = found.routes[method];
+		if (!route) {
+			const response = bookingErrorResponse("methodNotAllowed", 405);
+			response.headers.set("Allow", Object.keys(found.routes).join(", "));
+			return response;
+		}
+		if (rt.options.rateLimit && await rt.options.rateLimit(found.scope, request)) return NextResponse.json({ error: "rateLimited" }, {
+			status: 429,
+			headers: { "Cache-Control": "no-store" }
+		});
+		return route(rt, request, found.segment);
+	}
+	return {
+		GET: (request) => handle("GET", request),
+		POST: (request) => handle("POST", request),
+		DELETE: (request) => handle("DELETE", request)
+	};
+}
+//#endregion
+export { createBookingHandlerFor };
+
+//# sourceMappingURL=handler.mjs.map

package/dist/next/handler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.mjs","names":[],"sources":["../../src/next/handler.ts"],"sourcesContent":["/**\n * One drop-in handler for every booking and portal API route.\n *\n * An app mounts it on two catch-alls and is done:\n *\n * ```ts\n * // app/api/booking/[...path]/route.ts and app/api/portal/[...path]/route.ts\n * export const { GET, POST, DELETE } = booking.handler;\n * ```\n *\n * It dispatches on the path after `config.paths.api` / `config.paths.portalApi`:\n *\n * | Path (after the prefix) | Methods |\n * |---|---|\n * | `services`, `resources`, `availability`, `schedule`, `next-free` | GET |\n * | `avatar/<resourceId>` | GET |\n * | `create` | POST |\n * | `manage/<token>` | GET (the booking), POST (`cancel` / `reschedule`) |\n * | portal `login/verify`, `persons`, `session/touch`, `vipps/link/verify` | POST |\n * | portal `session/expired` | GET |\n * | portal `vipps/flash` | DELETE |\n *\n * Static routes in the app still win over the catch-all in Next, so a site\n * keeps any route of its own beside these.\n */\n\nimport { NextResponse } from 'next/server';\nimport {\n  availabilityRoute,\n  avatarRoute,\n  nextFreeRoute,\n  resourcesRoute,\n  scheduleRoute,\n  servicesRoute,\n} from './routes/catalogue-routes';\nimport { createRoute } from './routes/create';\nimport { manageRoute, manageSummaryRoute } from './routes/manage';\nimport {\n  loginVerifyRoute,\n  personsRoute,\n  sessionExpiredRoute,\n  sessionTouchRoute,\n  vippsFlashRoute,\n  vippsLinkVerifyRoute,\n} from './routes/portal-routes';\nimport { bookingErrorResponse } from './routes/shared';\nimport type { BookingRuntime } from './runtime';\n\ntype Method = 'GET' | 'POST' | 'DELETE';\n\ntype Route = (rt: BookingRuntime, request: Request, segment: string) => Promise<Response>;\n\ninterface Match {\n  scope: string;\n  routes: Partial<Record<Method, Route>>;\n  /** The decoded trailing segment, for `avatar/<id>` and `manage/<token>`. */\n  segment: string;\n}\n\nconst BOOKING_ROUTES: Record<string, Partial<Record<Method, Route>>> = {\n  services: { GET: (rt) => servicesRoute(rt) },\n  resources: { GET: (rt, request) => resourcesRoute(rt, request) },\n  availability: { GET: (rt, request) => availabilityRoute(rt, request) },\n  schedule: { GET: (rt, request) => scheduleRoute(rt, request) },\n  'next-free': { GET: (rt) => nextFreeRoute(rt) },\n  create: { POST: (rt, request) => createRoute(rt, request) },\n};\n\nconst BOOKING_PARAM_ROUTES: Record<string, Partial<Record<Method, Route>>> = {\n  avatar: { GET: (rt, request, segment) => avatarRoute(rt, request, segment) },\n  manage: {\n    GET: (rt, request, segment) => manageSummaryRoute(rt, request, segment),\n    POST: (rt, request, segment) => manageRoute(rt, request, segment),\n  },\n};\n\nconst PORTAL_ROUTES: Record<string, Partial<Record<Method, Route>>> = {\n  'login/verify': { POST: (rt, request) => loginVerifyRoute(rt, request) },\n  persons: { POST: (rt, request) => personsRoute(rt, request) },\n  'session/touch': { POST: (rt) => sessionTouchRoute(rt) },\n  'session/expired': { GET: (rt, request) => sessionExpiredRoute(rt, request) },\n  'vipps/flash': { DELETE: (rt, request) => vippsFlashRoute(rt, request) },\n  'vipps/link/verify': { POST: (rt, request) => vippsLinkVerifyRoute(rt, request) },\n};\n\n/** The rest of `pathname` after `prefix`, or `null` when it is not under it. */\nfunction under(pathname: string, prefix: string): string | null {\n  const base = prefix.replace(/\\/+$/, '');\n  if (!pathname.startsWith(`${base}/`)) return null;\n  return pathname.slice(base.length + 1).replace(/\\/+$/, '');\n}\n\nfunction decoded(segment: string): string | null {\n  try {\n    return decodeURIComponent(segment);\n  } catch {\n    return null;\n  }\n}\n\nfunction matchBooking(rest: string): Match | 'malformed' | null {\n  const fixed = BOOKING_ROUTES[rest];\n  if (fixed) return { scope: `booking/${rest}`, routes: fixed, segment: '' };\n  const slash = rest.indexOf('/');\n  if (slash > 0) {\n    const head = rest.slice(0, slash);\n    const tail = rest.slice(slash + 1);\n    const routes = BOOKING_PARAM_ROUTES[head];\n    if (routes && tail !== '' && !tail.includes('/')) {\n      const segment = decoded(tail);\n      if (segment === null) return 'malformed';\n      return { scope: `booking/${head}`, routes, segment };\n    }\n  }\n  return null;\n}\n\nfunction matchPortal(rest: string): Match | null {\n  const routes = PORTAL_ROUTES[rest];\n  return routes ? { scope: `portal/${rest}`, routes, segment: '' } : null;\n}\n\n/**\n * The route a path names. The LONGER prefix is tried first, so a portal API\n * nested under the booking API (`/api` and `/api/portal`) still reaches the\n * portal routes, and the other way round.\n */\nfunction match(rt: BookingRuntime, pathname: string): Match | 'malformed' | null {\n  const { api, portalApi } = rt.config.paths;\n  const prefixes = [\n    { prefix: api, find: matchBooking },\n    { prefix: portalApi, find: matchPortal },\n  ].sort((a, b) => b.prefix.replace(/\\/+$/, '').length - a.prefix.replace(/\\/+$/, '').length);\n  for (const { prefix, find } of prefixes) {\n    const rest = under(pathname, prefix);\n    if (rest === null) continue;\n    const found = find(rest);\n    if (found !== null) return found;\n  }\n  return null;\n}\n\nexport interface BookingHandler {\n  GET(request: Request): Promise<Response>;\n  POST(request: Request): Promise<Response>;\n  DELETE(request: Request): Promise<Response>;\n}\n\n/** The handler over an existing runtime (what `createBookingServer` shares). */\nexport function createBookingHandlerFor(rt: BookingRuntime): BookingHandler {\n  async function handle(method: Method, request: Request): Promise<Response> {\n    const found = match(rt, new URL(request.url).pathname);\n    if (found === 'malformed')\n      return bookingErrorResponse('invalidInput', 400, 'path is malformed');\n    if (found === null) return bookingErrorResponse('notFound', 404);\n    const route = found.routes[method];\n    if (!route) {\n      const response = bookingErrorResponse('methodNotAllowed', 405);\n      response.headers.set('Allow', Object.keys(found.routes).join(', '));\n      return response;\n    }\n    if (rt.options.rateLimit && (await rt.options.rateLimit(found.scope, request))) {\n      return NextResponse.json(\n        { error: 'rateLimited' },\n        { status: 429, headers: { 'Cache-Control': 'no-store' } }\n      );\n    }\n    return route(rt, request, found.segment);\n  }\n\n  return {\n    GET: (request) => handle('GET', request),\n    POST: (request) => handle('POST', request),\n    DELETE: (request) => handle('DELETE', request),\n  };\n}\n"],"mappings":"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"}

package/dist/next/index.d.mts

@@ -0,0 +1,17 @@
+import { CreateBookingBody, CreateBookingResult, DEFAULT_MEDAL_ENDPOINT, MedalApiError, MedalConfigError, MedalSeam, MedalSeamOptions, RangeArgs, RecordConsentBody, RescheduleResult, createMedalSeam, looksLikePlaceholderKey } from "./medal.mjs";
+import { BookingCacheAdapter, BookingLogger, BookingPortalServerOptions, BookingRateLimit, BookingServerOptions, BookingTiming, BookingTimingPhase, DEFAULT_AVATAR_HOSTS, DEFAULT_EDGE_PREFIX, DEFAULT_PORTAL_MESSAGES, PortalMessages } from "./options.mjs";
+import { CATALOGUE_TAG, Catalogue, ReadOptions, createCatalogue, slotKeyStart, slotsTag } from "./catalogue.mjs";
+import { PersonTarget, PortalPersonInput, PortalPersonResult, PortalSeam, PortalSessionExpiredError, PortalThrottledError, PortalValidationError, PortalVippsConflictError, PortalVippsUnavailableError, VippsLinkCompletion } from "./portal/medal-portal.mjs";
+import { toBookingFamilyMember } from "./portal/guardian.mjs";
+import { PortalSession, RENEWED_SESSION_LIFETIME_MS } from "./portal/session.mjs";
+import { VIPPS_LINK_FLASHES, VippsLinkFlash, vippsLinkFlash } from "./portal/vipps-flash.mjs";
+import { BookingCatalogue, BookingSeed, SEED_RECHECK_MS, SEED_STALE_MAX_MS, Seed, SeedState, createSeed } from "./seed.mjs";
+import { BookingRuntime, createBookingRuntime } from "./runtime.mjs";
+import { BookingHandler } from "./handler.mjs";
+import { BookingContact, BookingPageResult, ManagePageResult, PageSwitches, PortalPageResult } from "./loaders.mjs";
+import { toManageDto } from "./manage-dto.mjs";
+import { InvalidInput, PersonActionResult, Portal, PortalActions, PortalSchemas, SessionFailure, UpdateProfileResult, VerifyLoginResult, VippsLinkStartState, VippsStartState } from "./portal.mjs";
+import { isCrossOriginRequest, originFromHeaders, readBoundedText } from "./request.mjs";
+import { BookingServer, createBookingHandler, createBookingServer, createPortal, loadBookingPage, loadManagePage, loadPortalPage } from "./server.mjs";
+import "server-only";
+export { type BookingCacheAdapter, type BookingCatalogue, type BookingContact, type BookingHandler, type BookingLogger, type BookingPageResult, type BookingPortalServerOptions, type BookingRateLimit, type BookingRuntime, type BookingSeed, type BookingServer, type BookingServerOptions, type BookingTiming, type BookingTimingPhase, CATALOGUE_TAG, type Catalogue, type CreateBookingBody, type CreateBookingResult, DEFAULT_AVATAR_HOSTS, DEFAULT_EDGE_PREFIX, DEFAULT_MEDAL_ENDPOINT, DEFAULT_PORTAL_MESSAGES, type InvalidInput, type ManagePageResult, MedalApiError, MedalConfigError, type MedalSeam, type MedalSeamOptions, type PageSwitches, type PersonActionResult, type PersonTarget, type Portal, type PortalActions, type PortalMessages, type PortalPageResult, type PortalPersonInput, type PortalPersonResult, type PortalSchemas, type PortalSeam, type PortalSession, PortalSessionExpiredError, PortalThrottledError, PortalValidationError, PortalVippsConflictError, PortalVippsUnavailableError, RENEWED_SESSION_LIFETIME_MS, type RangeArgs, type ReadOptions, type RecordConsentBody, type RescheduleResult, SEED_RECHECK_MS, SEED_STALE_MAX_MS, type Seed, type SeedState, type SessionFailure, type UpdateProfileResult, VIPPS_LINK_FLASHES, type VerifyLoginResult, type VippsLinkCompletion, type VippsLinkFlash, type VippsLinkStartState, type VippsStartState, createBookingHandler, createBookingRuntime, createBookingServer, createCatalogue, createMedalSeam, createPortal, createSeed, isCrossOriginRequest, loadBookingPage, loadManagePage, loadPortalPage, looksLikePlaceholderKey, originFromHeaders, readBoundedText, slotKeyStart, slotsTag, toBookingFamilyMember, toManageDto, vippsLinkFlash };

package/dist/next/index.mjs

@@ -0,0 +1,14 @@
+import { DEFAULT_AVATAR_HOSTS, DEFAULT_EDGE_PREFIX, DEFAULT_PORTAL_MESSAGES } from "./options.mjs";
+import { CATALOGUE_TAG, createCatalogue, slotKeyStart, slotsTag } from "./catalogue.mjs";
+import { toManageDto } from "./manage-dto.mjs";
+import { DEFAULT_MEDAL_ENDPOINT, MedalApiError, MedalConfigError, createMedalSeam, looksLikePlaceholderKey } from "./medal.mjs";
+import { toBookingFamilyMember } from "./portal/guardian.mjs";
+import { PortalSessionExpiredError, PortalThrottledError, PortalValidationError, PortalVippsConflictError, PortalVippsUnavailableError } from "./portal/medal-portal.mjs";
+import { RENEWED_SESSION_LIFETIME_MS } from "./portal/session.mjs";
+import { VIPPS_LINK_FLASHES, vippsLinkFlash } from "./portal/vipps-flash.mjs";
+import { isCrossOriginRequest, originFromHeaders, readBoundedText } from "./request.mjs";
+import { SEED_RECHECK_MS, SEED_STALE_MAX_MS, createSeed } from "./seed.mjs";
+import { createBookingRuntime } from "./runtime.mjs";
+import { createBookingHandler, createBookingServer, createPortal, loadBookingPage, loadManagePage, loadPortalPage } from "./server.mjs";
+import "server-only";
+export { CATALOGUE_TAG, DEFAULT_AVATAR_HOSTS, DEFAULT_EDGE_PREFIX, DEFAULT_MEDAL_ENDPOINT, DEFAULT_PORTAL_MESSAGES, MedalApiError, MedalConfigError, PortalSessionExpiredError, PortalThrottledError, PortalValidationError, PortalVippsConflictError, PortalVippsUnavailableError, RENEWED_SESSION_LIFETIME_MS, SEED_RECHECK_MS, SEED_STALE_MAX_MS, VIPPS_LINK_FLASHES, createBookingHandler, createBookingRuntime, createBookingServer, createCatalogue, createMedalSeam, createPortal, createSeed, isCrossOriginRequest, loadBookingPage, loadManagePage, loadPortalPage, looksLikePlaceholderKey, originFromHeaders, readBoundedText, slotKeyStart, slotsTag, toBookingFamilyMember, toManageDto, vippsLinkFlash };

package/dist/next/loaders.d.mts

@@ -0,0 +1,79 @@
+import { BookingConfig } from "../core/config.mjs";
+import { BookingGuardian, BookingManageDto, BookingServiceDto } from "../core/types.mjs";
+import { PortalBookingDto, PortalProfileDto } from "../core/portal/dto.mjs";
+import { VippsLinkFlash } from "./portal/vipps-flash.mjs";
+import { BookingSeed } from "./seed.mjs";
+import "./runtime.mjs";
+//#region src/next/loaders.d.ts
+/** The business's own contact, for «call us» and the unavailable screens. */
+export interface BookingContact {
+  phone: string | null;
+  address: string | null;
+}
+/** The per-request switches a site resolves itself (from a CMS, say). */
+export interface PageSwitches {
+  /** Set = the booking page hands off here. Default `config.handoffUrl`. */
+  handoffUrl?: string | null;
+  /** Default `config.contact`. */
+  contact?: BookingContact;
+}
+export type BookingPageResult = {
+  kind: 'redirect';
+  href: string;
+} | {
+  kind: 'unavailable';
+  contact: BookingContact;
+} | {
+  kind: 'ready';
+  seed: BookingSeed;
+  guardian: BookingGuardian | null;
+  config: Readonly<BookingConfig>;
+  contact: BookingContact;
+  /** The window the seed describes; the wizard's day strip must use the same. */
+  rangeDays: number;
+};
+export type ManagePageResult = {
+  kind: 'unreachable';
+  retryHref: string;
+  contact: BookingContact;
+} | {
+  kind: 'unknown';
+  bookingHref: string;
+  contact: BookingContact;
+} | {
+  kind: 'ready';
+  booking: BookingManageDto;
+  service: BookingServiceDto | null;
+  /** Where the page POSTs cancel / reschedule. */
+  actionPath: string;
+  /** The page's own URL, for the calendar entry's «change or cancel» line. */
+  selfManagePath: string;
+  bookingHref: string;
+  contact: BookingContact;
+};
+export type PortalPageResult = {
+  kind: 'disabled';
+} | {
+  kind: 'redirect';
+  href: string;
+} | {
+  kind: 'unreachable';
+  contact: BookingContact;
+} | {
+  kind: 'ready';
+  profile: PortalProfileDto;
+  bookings: {
+    upcoming: PortalBookingDto[];
+    past: PortalBookingDto[];
+  };
+  stylists: Array<{
+    id: string;
+    name: string;
+  }>;
+  /** How a «link Vipps» attempt just ended, for the profile section to say. */
+  vippsFlash: VippsLinkFlash | null;
+  bookingHref: string;
+  contact: BookingContact;
+};
+//#endregion
+//# sourceMappingURL=loaders.d.mts.map