@btst/stack 5.1.0 → 5.2.0

package/src/plugins/calendar/scheduling.ts

@@ -0,0 +1,174 @@
+import type { DeepReadonly } from "@btst/stack/plugins/api";
+import type { Availability, Booking, EventType } from "./types";
+
+function dateFormatter(timezone: string) {
+	return new Intl.DateTimeFormat("en-CA", {
+		timeZone: timezone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		hourCycle: "h23",
+	});
+}
+
+function localParts(formatter: Intl.DateTimeFormat, date: Date) {
+	const parts = formatter.formatToParts(date);
+	const value = (type: Intl.DateTimeFormatPartTypes) =>
+		parts.find((part) => part.type === type)!.value;
+	const day = `${value("year")}-${value("month")}-${value("day")}`;
+	return {
+		date: day,
+		minute: Number(value("hour")) * 60 + Number(value("minute")),
+	};
+}
+
+function minutes(time: string) {
+	return Number(time.slice(0, 2)) * 60 + Number(time.slice(3));
+}
+
+function weekStart(date: string) {
+	const day = new Date(`${date}T00:00:00Z`);
+	day.setUTCDate(day.getUTCDate() - ((day.getUTCDay() + 6) % 7));
+	return day.toISOString().slice(0, 10);
+}
+
+/** Calculate slots in the viewer's local date, preserving real DST instants. */
+export function calculateAvailability(
+	event: DeepReadonly<EventType>,
+	bookings: readonly DeepReadonly<Booking>[],
+	date: string,
+	timezone: string,
+	now = new Date(),
+): Availability {
+	const slots: Availability["slots"] = [];
+	if (!event.active) return { date, timezone, slots };
+	const viewer = dateFormatter(timezone);
+	const host = dateFormatter(event.timezone);
+	const dayCenter = Date.parse(`${date}T00:00:00Z`);
+	const duration = event.duration * 60_000;
+	const earliestStart = dayCenter - 24 * 60 * 60_000;
+	const latestStart = dayCenter + 48 * 60 * 60_000;
+	const hourCounts =
+		event.limits.perHour === undefined ? undefined : new Map<string, number>();
+	const dayCounts =
+		event.limits.perDay === undefined ? undefined : new Map<string, number>();
+	const weekCounts =
+		event.limits.perWeek === undefined ? undefined : new Map<string, number>();
+	let totalCount = 0;
+	const possibleOverlaps: {
+		eventTypeId: string;
+		start: number;
+		end: number;
+	}[] = [];
+	for (const booking of bookings) {
+		if (booking.status !== "confirmed") continue;
+		const start = Date.parse(booking.start);
+		const end = Date.parse(booking.end);
+		if (start < latestStart + duration && end > earliestStart)
+			possibleOverlaps.push({ eventTypeId: booking.eventTypeId, start, end });
+		if (booking.eventTypeId !== event.id) continue;
+		if (event.limits.total !== undefined) totalCount++;
+		if (!hourCounts && !dayCounts && !weekCounts) continue;
+		const local = localParts(host, new Date(start));
+		if (hourCounts) {
+			const hour = `${local.date}:${Math.floor(local.minute / 60)}`;
+			hourCounts.set(hour, (hourCounts.get(hour) ?? 0) + 1);
+		}
+		if (dayCounts)
+			dayCounts.set(local.date, (dayCounts.get(local.date) ?? 0) + 1);
+		if (weekCounts) {
+			const week = weekStart(local.date);
+			weekCounts.set(week, (weekCounts.get(week) ?? 0) + 1);
+		}
+	}
+	const hostTimes = new Map<number, ReturnType<typeof localParts>>();
+	const hostTime = (instant: number) => {
+		let value = hostTimes.get(instant);
+		if (!value) {
+			value = localParts(host, new Date(instant));
+			hostTimes.set(instant, value);
+		}
+		return value;
+	};
+	// IANA offsets fit within 24 hours; this also includes both fall-back instants.
+	for (let start = earliestStart; start < latestStart; start += 60_000) {
+		if (start <= now.getTime()) continue;
+		const instant = new Date(start);
+		if (localParts(viewer, instant).date !== date) continue;
+		const local = hostTime(start);
+		const weekday = new Date(`${local.date}T00:00:00Z`).getUTCDay();
+		const override = event.dateOverrides.find(
+			(item) => item.date === local.date,
+		);
+		const intervals =
+			override?.intervals ??
+			event.weeklyAvailability.filter((item) => item.dayOfWeek === weekday);
+		const end = start + duration;
+		const fits = intervals.some((interval) => {
+			const first = minutes(interval.start);
+			const last = minutes(interval.end);
+			if (local.minute < first || (local.minute - first) % event.duration !== 0)
+				return false;
+			// Every real minute must remain inside the wall-clock interval, including DST folds.
+			for (let minute = start; minute < end; minute += 60_000) {
+				const part = hostTime(minute);
+				if (
+					part.date !== local.date ||
+					part.minute < first ||
+					part.minute >= last
+				)
+					return false;
+			}
+			return true;
+		});
+		if (!fits) continue;
+		let attendeeCount = 0;
+		let blocked = false;
+		for (const booking of possibleOverlaps) {
+			if (booking.start >= end || booking.end <= start) continue;
+			if (
+				booking.eventTypeId !== event.id ||
+				booking.start !== start ||
+				booking.end !== end
+			) {
+				blocked = true;
+				break;
+			}
+			attendeeCount++;
+		}
+		if (blocked) continue;
+		let remaining = event.capacity - attendeeCount;
+		if (hourCounts)
+			remaining = Math.min(
+				remaining,
+				event.limits.perHour! -
+					(hourCounts.get(`${local.date}:${Math.floor(local.minute / 60)}`) ??
+						0),
+			);
+		if (dayCounts)
+			remaining = Math.min(
+				remaining,
+				event.limits.perDay! - (dayCounts.get(local.date) ?? 0),
+			);
+		if (weekCounts)
+			remaining = Math.min(
+				remaining,
+				event.limits.perWeek! - (weekCounts.get(weekStart(local.date)) ?? 0),
+			);
+		if (event.limits.total !== undefined)
+			remaining = Math.min(remaining, event.limits.total - totalCount);
+		if (remaining > 0)
+			slots.push({
+				start: instant.toISOString(),
+				end: new Date(end).toISOString(),
+				remaining,
+			});
+	}
+	return { date, timezone, slots };
+}
+
+export function dateInTimezone(instant: string, timezone: string) {
+	return localParts(dateFormatter(timezone), new Date(instant)).date;
+}

package/src/plugins/calendar/schemas.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+
+export const timezoneSchema = z
+	.string()
+	.min(1)
+	.max(100)
+	.refine((zone) => {
+		try {
+			new Intl.DateTimeFormat("en", { timeZone: zone }).format();
+			return true;
+		} catch {
+			return false;
+		}
+	}, "Invalid timezone");
+
+export const calendarDateSchema = z.iso.date();
+const timeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/);
+const endTimeSchema = z.union([timeSchema, z.literal("24:00")]);
+const intervalSchema = z
+	.object({ start: timeSchema, end: endTimeSchema })
+	.refine(
+		({ start, end }) => start < end,
+		"Availability must end after it starts",
+	);
+export const weeklyAvailabilitySchema = z
+	.object({
+		dayOfWeek: z.number().int().min(0).max(6),
+		start: timeSchema,
+		end: endTimeSchema,
+	})
+	.refine(
+		({ start, end }) => start < end,
+		"Availability must end after it starts",
+	);
+export const dateOverrideSchema = z.object({
+	date: calendarDateSchema,
+	intervals: z.array(intervalSchema).max(24),
+});
+const limitSchema = z.number().int().positive().max(1_000_000).optional();
+export const bookingLimitsSchema = z.object({
+	perHour: limitSchema,
+	perDay: limitSchema,
+	perWeek: limitSchema,
+	total: limitSchema,
+});
+
+export const createEventTypeSchema = z.object({
+	slug: z
+		.string()
+		.min(1)
+		.max(100)
+		.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+	name: z.string().trim().min(1).max(200),
+	description: z.string().max(5000).default(""),
+	location: z.string().max(500).default(""),
+	duration: z.number().int().min(1).max(1440),
+	capacity: z.number().int().min(1).max(10000).default(1),
+	timezone: timezoneSchema,
+	weeklyAvailability: z.array(weeklyAvailabilitySchema).max(168).default([]),
+	dateOverrides: z
+		.array(dateOverrideSchema)
+		.max(366)
+		.default([])
+		.refine(
+			(overrides) =>
+				new Set(overrides.map((override) => override.date)).size ===
+				overrides.length,
+			"Only one override is allowed per date",
+		),
+	limits: bookingLimitsSchema.default({}),
+	active: z.boolean().default(true),
+});
+
+export const createBookingSchema = z.object({
+	start: z.iso.datetime({ offset: true }),
+	timezone: timezoneSchema,
+	name: z.string().trim().min(1).max(200),
+	email: z
+		.email()
+		.max(320)
+		.transform((value) => value.toLowerCase()),
+});
+export const availabilityQuerySchema = z.object({
+	date: calendarDateSchema,
+	timezone: timezoneSchema,
+});
+export const listBookingsQuerySchema = z.object({
+	period: z.enum(["upcoming", "past", "all"]).default("upcoming"),
+	eventTypeId: z.string().min(1).optional(),
+});

package/src/plugins/calendar/style.css

@@ -0,0 +1,4 @@
+@import "./client.css";
+
+@source "../../../src/**/*.{ts,tsx}";
+@source "../../packages/ui/src";

package/src/plugins/calendar/types.ts

@@ -0,0 +1,76 @@
+/** Host-local wall-clock interval, using HH:mm and exclusive end (24:00 allowed). */
+export type TimeInterval = { start: string; end: string };
+/** Repeating host availability; Sunday is 0 and Saturday is 6. */
+export type WeeklyAvailability = TimeInterval & { dayOfWeek: number };
+/** Replaces weekly availability on a host-local YYYY-MM-DD date; [] blocks the date. */
+export type DateOverride = { date: string; intervals: TimeInterval[] };
+/** Confirmed attendee limits per event type, in host-local calendar periods; total is lifetime. */
+export type BookingLimits = {
+	perHour?: number;
+	perDay?: number;
+	perWeek?: number;
+	total?: number;
+};
+
+/** Event configuration serialized for HTTP and React Query. Duration is real elapsed minutes. */
+export type EventType = {
+	id: string;
+	hostId: string;
+	slug: string;
+	name: string;
+	description: string;
+	location: string;
+	duration: number;
+	capacity: number;
+	timezone: string;
+	weeklyAvailability: WeeklyAvailability[];
+	dateOverrides: DateOverride[];
+	limits: BookingLimits;
+	active: boolean;
+	createdAt: string;
+	updatedAt: string;
+};
+
+/** Reservation with ISO instants. cancelToken is a private bearer secret; management responses redact it. */
+export type Booking = {
+	id: string;
+	eventTypeId: string;
+	hostId: string;
+	eventName: string;
+	start: string;
+	end: string;
+	timezone: string;
+	name: string;
+	email: string;
+	status: "confirmed" | "cancelled";
+	cancelToken: string;
+	createdAt: string;
+};
+
+/** UTC ISO slot instants and the remaining attendee reservations, including booking limits. */
+export type AvailableSlot = { start: string; end: string; remaining: number };
+/** Availability for one viewer-local date in the requested IANA timezone. */
+export type Availability = {
+	slots: AvailableSlot[];
+	date: string;
+	timezone: string;
+};
+
+/** Storage shape: structured configuration is JSON text and timestamps are Date values. */
+export type EventTypeRecord = Omit<
+	EventType,
+	"weeklyAvailability" | "dateOverrides" | "limits" | "createdAt" | "updatedAt"
+> & {
+	weeklyAvailability: string;
+	dateOverrides: string;
+	limits: string;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+/** Storage shape of a reservation, including its private cancellation token. */
+export type BookingRecord = Omit<Booking, "start" | "end" | "createdAt"> & {
+	start: Date;
+	end: Date;
+	createdAt: Date;
+};

package/src/plugins/crm/__tests__/cache-invalidation.test.tsx

@@ -0,0 +1,145 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createClientStack } from "../../../client";
+import { StackProvider } from "../../../context";
+import { defineClientPlugin } from "../../../plugins/client";
+import { createResource } from "../../../plugins/client/hooks";
+import { createCrmQueryKeys, crmResources } from "../query-keys";
+
+(
+	globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+const crm = createResource({ plugin: "crm", resources: crmResources });
+const keys = createCrmQueryKeys(vi.fn());
+const cachedQueries = {
+	contacts: keys.crmContacts.list({}).queryKey,
+	contact: keys.crmContacts.detail("contact").queryKey,
+	companies: keys.crmCompanies.list({}).queryKey,
+	company: keys.crmCompanies.detail("company").queryKey,
+	deals: keys.crmDeals.list({}).queryKey,
+	deal: keys.crmDeals.detail("deal").queryKey,
+	activities: keys.crmActivities.list({ dealId: "deal" }).queryKey,
+	pipelines: keys.crmPipelines.list({}).queryKey,
+	pipeline: keys.crmPipelines.detail("pipeline").queryKey,
+};
+type CachedQuery = keyof typeof cachedQueries;
+
+describe("CRM dependent cache invalidation", () => {
+	let root: Root;
+	let container: HTMLDivElement;
+	let queryClient: QueryClient;
+	beforeEach(() => {
+		queryClient = new QueryClient();
+		container = document.createElement("div");
+		document.body.appendChild(container);
+		root = createRoot(container);
+		vi.spyOn(globalThis, "fetch").mockImplementation(
+			async () =>
+				new Response(JSON.stringify({ success: true }), {
+					headers: { "content-type": "application/json" },
+				}),
+		);
+		for (const key of Object.values(cachedQueries))
+			queryClient.setQueryData(key, { id: "linked-record" });
+	});
+	afterEach(async () => {
+		await act(async () => root.unmount());
+		container.remove();
+		queryClient.clear();
+		vi.restoreAllMocks();
+	});
+	async function mutate(
+		useMutation: () => { mutateAsync: (input: string) => Promise<unknown> },
+	) {
+		const stack = createClientStack({
+			api: { baseURL: "https://example.test", basePath: "/api/data" },
+			site: { baseURL: "https://example.test", basePath: "/pages" },
+			queryClient,
+			plugins: {
+				crm: defineClientPlugin({
+					id: "crm",
+					resolve: () => ({ routes: () => ({}) }),
+				}),
+			},
+		});
+		let mutation!: ReturnType<typeof useMutation>;
+		function Probe() {
+			mutation = useMutation();
+			return null;
+		}
+		await act(async () =>
+			root.render(
+				<StackProvider stack={stack} router={{}}>
+					<Probe />
+				</StackProvider>,
+			),
+		);
+		await act(async () => {
+			await mutation.mutateAsync("deleted-record");
+		});
+	}
+	it.each<{
+		resource: "crmCompanies" | "crmContacts" | "crmDeals";
+		stale: CachedQuery[];
+	}>([
+		{
+			resource: "crmCompanies",
+			stale: [
+				"companies",
+				"company",
+				"contacts",
+				"contact",
+				"deals",
+				"deal",
+				"pipelines",
+				"pipeline",
+			],
+		},
+		{
+			resource: "crmContacts",
+			stale: [
+				"contacts",
+				"contact",
+				"deals",
+				"deal",
+				"activities",
+				"pipelines",
+				"pipeline",
+			],
+		},
+		{
+			resource: "crmDeals",
+			stale: ["deals", "deal", "activities", "pipelines", "pipeline"],
+		},
+	])(
+		"refreshes dependent cached records after deleting $resource",
+		async ({ resource, stale }) => {
+			await mutate(() => crm[resource].delete.use());
+			for (const [name, key] of Object.entries(cachedQueries))
+				expect(queryClient.getQueryState(key)?.isInvalidated, name).toBe(
+					stale.includes(name as CachedQuery),
+				);
+		},
+	);
+	it("refreshes contact search membership when a linked company is renamed", async () => {
+		await mutate(() => {
+			const mutation = crm.crmCompanies.update.use();
+			return {
+				mutateAsync: (id: string) =>
+					mutation.mutateAsync({ id, data: { name: "Renamed company" } }),
+			};
+		});
+		expect(
+			queryClient.getQueryState(cachedQueries.contacts)?.isInvalidated,
+		).toBe(true);
+		expect(
+			queryClient.getQueryState(cachedQueries.contact)?.isInvalidated,
+		).toBe(false);
+		expect(
+			queryClient.getQueryState(cachedQueries.activities)?.isInvalidated,
+		).toBe(false);
+	});
+});