better-supabase 0.8.0 → 0.10.0

package/dist/client-D727oIVC.js

@@ -0,0 +1,169 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { a as ok, r as err } from "./result-COkvI9t5.js";
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+import { R as toInstant } from "./block-helpers-BfVCR5Fc.js";
+import { t as authResult } from "./auth-reply-B_dW4jHJ.js";
+//#region src/blocks/sessions/client.ts
+const filled = (value) => value === null || value === void 0 || value === "" ? void 0 : value;
+const clientInfo = (raw) => ({
+	id: raw.id,
+	name: raw.name,
+	uri: filled(raw.uri),
+	logoUri: filled(raw.logo_uri)
+});
+const hostOf = (uri) => {
+	try {
+		return new URL(uri).host;
+	} catch {
+		return uri;
+	}
+};
+/**
+* Reads per authorization id. A request the user approved before is used up
+* by its first read, so a second controller for the same id (React Strict
+* Mode mounts twice) has to share the answer.
+*/
+const reads = /* @__PURE__ */ new Map();
+async function readDetails(oauth, authorizationId) {
+	const result = await authResult(() => oauth.getAuthorizationDetails(authorizationId));
+	if (!result.ok) return result;
+	const data = result.data;
+	if (!("authorization_id" in data)) return ok({ redirectUrl: data.redirect_url });
+	return ok({
+		authorizationId: data.authorization_id,
+		client: clientInfo(data.client),
+		user: data.user,
+		scopes: data.scope.split(" ").filter((scope) => scope !== ""),
+		redirectUri: data.redirect_uri,
+		redirectHost: hostOf(data.redirect_uri)
+	});
+}
+const assign = (url) => {
+	globalThis.location.assign(url);
+};
+/**
+* The consent page of the Supabase Auth OAuth server: it reads the request
+* for `authorizationId`, and `approve` or `deny` send the browser to the
+* `redirect_url` that Auth returns, never to a URL from the page.
+*/
+function createOAuthConsentController(options) {
+	const { oauth, authorizationId } = options;
+	const redirect = options.redirect ?? assign;
+	return defineController({
+		request: void 0,
+		redirectUrl: void 0,
+		deciding: void 0,
+		error: void 0
+	}, (state) => {
+		const leave = (url) => {
+			state.set({
+				request: void 0,
+				redirectUrl: url
+			});
+			redirect(url);
+		};
+		const load = async (id) => {
+			let read = reads.get(id);
+			if (read === void 0) {
+				read = readDetails(oauth, id);
+				reads.set(id, read);
+			}
+			const run = state.run();
+			const result = await read;
+			if (run !== state.run()) return;
+			if (!result.ok) {
+				reads.delete(id);
+				state.set({ error: result.error });
+				return;
+			}
+			if ("redirectUrl" in result.data) {
+				leave(result.data.redirectUrl);
+				return;
+			}
+			state.set({
+				request: result.data,
+				error: void 0
+			});
+		};
+		const decide = async (decision) => {
+			const id = state.get().request?.authorizationId;
+			if (id === void 0 || state.get().deciding !== void 0) return err(dbError("invalid_input", "No authorization request to decide"));
+			state.set({
+				deciding: decision,
+				error: void 0
+			});
+			const result = await authResult(() => decision === "approve" ? oauth.approveAuthorization(id, { skipBrowserRedirect: true }) : oauth.denyAuthorization(id, { skipBrowserRedirect: true }));
+			if (!result.ok) {
+				state.set({
+					deciding: void 0,
+					error: result.error
+				});
+				return result;
+			}
+			reads.delete(id);
+			leave(result.data.redirect_url);
+			return ok(result.data.redirect_url);
+		};
+		return {
+			actions: {
+				approve: () => decide("approve"),
+				deny: () => decide("deny")
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				if (authorizationId !== void 0) load(authorizationId);
+			})
+		};
+	});
+}
+/** The OAuth clients (such as MCP clients) the user approved, for a connected agents list. */
+function createOAuthGrantsController(options) {
+	const { oauth } = options;
+	return defineController({
+		grants: void 0,
+		revoking: [],
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			const request = ++ticket;
+			const result = await authResult(() => oauth.listGrants());
+			if (request !== ticket) return;
+			if (!result.ok) {
+				state.set({ error: result.error });
+				return;
+			}
+			state.set({
+				grants: result.data.map((grant) => ({
+					client: clientInfo(grant.client),
+					scopes: grant.scopes,
+					grantedAt: toInstant(grant.granted_at)
+				})).toSorted((a, b) => b.grantedAt.epochMilliseconds - a.grantedAt.epochMilliseconds),
+				error: void 0
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				revoke: async (clientId) => {
+					state.set((current) => ({
+						revoking: [...current.revoking, clientId],
+						error: void 0
+					}));
+					const result = await authResult(() => oauth.revokeGrant({ clientId }));
+					state.set((current) => ({
+						revoking: current.revoking.filter((each) => each !== clientId),
+						...result.ok ? {} : { error: result.error }
+					}));
+					if (!result.ok) return result;
+					await refresh();
+					return ok(true);
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
+export { createOAuthGrantsController as n, createOAuthConsentController as t };

package/dist/client-D9zBl9PT.d.ts

@@ -0,0 +1,103 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult, w as ErrorMapper } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as BlockTransport } from "./block-transport-NbUJygA7.js";
+import { r as BlockTemporalOptions } from "./block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "./block-hooks-C_WaodoA.js";
+import { p as SubscriptionStatus } from "./topic-Dgs-eSYQ.js";
+import { n as TopicPort } from "./watch-topic-D-rpUg5n.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/reactions/reactions.d.ts
+interface ReactionsOptions extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Reactions>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** One emoji on a subject. */
+interface ReactionCount {
+  /** The emoji, or a custom emoji's `:shortcode:`. */
+  readonly emoji: string;
+  readonly count: number;
+  /** Whether the signed-in user reacted with it. */
+  readonly reacted: boolean;
+  /** The first ten actors (user ids, or names the service passed), oldest first. */
+  readonly actors: readonly string[];
+}
+interface CustomEmoji {
+  readonly id: string;
+  /** Without the colons: `party-parrot` is used as `:party-parrot:`. */
+  readonly shortcode: string;
+  /** An attachment from the `attachments` module. */
+  readonly attachmentId?: string;
+  /** An `https://` image URL. */
+  readonly url?: string;
+  readonly createdAt: Temporal.Instant;
+}
+interface CustomEmojiInput {
+  readonly shortcode: string;
+  readonly attachmentId?: string;
+  readonly url?: string;
+}
+interface ReactOptions {
+  /** `false` removes the reaction. Default: `true`. */
+  readonly present?: boolean;
+  /** The service role reacts for this actor (default `service`). */
+  readonly actor?: string;
+}
+interface Reactions {
+  /** Adds or removes the caller's reaction; returns the subject's reactions. */
+  react(organizationId: string, subjectType: string, subjectId: string, emoji: string, options?: ReactOptions): AsyncResult<readonly ReactionCount[]>;
+  /** The reactions of up to 200 subjects of one type, by subject id. */
+  summary(organizationId: string, subjectType: string, subjectIds: readonly string[]): AsyncResult<Readonly<Record<string, readonly ReactionCount[]>>>;
+  /** The organization's custom emoji, by shortcode. */
+  customEmoji(organizationId: string): AsyncResult<readonly CustomEmoji[]>;
+  /** Adds a custom emoji, or replaces the image of an existing shortcode. */
+  saveCustomEmoji(organizationId: string, input: CustomEmojiInput): AsyncResult<CustomEmoji>;
+  /** Deletes a custom emoji and the reactions that used it. */
+  deleteCustomEmoji(id: string): AsyncResult<boolean>;
+}
+/** The topic the module broadcasts an organization's reaction changes to. */
+declare function reactionsTopic(organizationId: string, topic?: string): string;
+/** The `reactions` SQL module as typed calls. */
+declare function createReactions(options: ReactionsOptions): Reactions;
+//#endregion
+//#region src/blocks/reactions/client.d.ts
+interface ReactionsControllerOptions {
+  readonly client: Pick<Reactions, "summary" | "react">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  readonly organizationId: string;
+  readonly subjectType: string;
+  /** The subjects on screen, at most 200; `setSubjects` changes them. */
+  readonly subjectIds: readonly string[];
+  /** `blockConfig.reactions.options.topic` from `blocks.generated.ts`; `null` loads without listening. */
+  readonly topic?: string | null;
+}
+interface ReactionsSnapshot {
+  /** Reactions by subject id; `undefined` until the first load. */
+  readonly reactions: Readonly<Record<string, readonly ReactionCount[]>> | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface ReactionsActions {
+  /** Adds the emoji, or removes it when the user already reacted with it. */
+  readonly toggle: (subjectId: string, emoji: string) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+  /** Watches other subjects, such as the rows on screen after a scroll, and loads them. */
+  readonly setSubjects: (subjectIds: readonly string[]) => void;
+}
+type ReactionsController = Controller<ReactionsSnapshot, ReactionsActions>;
+/**
+ * The reactions of the subjects on screen, loaded again when anyone in the
+ * organization reacts to one of them. `toggle` feeds an emoji picker.
+ */
+declare function createReactionsController(options: ReactionsControllerOptions): ReactionsController;
+//#endregion
+export { createReactionsController as a, ReactOptions as c, ReactionsOptions as d, createReactions as f, ReactionsSnapshot as i, ReactionCount as l, ReactionsController as n, CustomEmoji as o, reactionsTopic as p, ReactionsControllerOptions as r, CustomEmojiInput as s, ReactionsActions as t, Reactions as u };

package/dist/client-DG7FwgZD.js

@@ -0,0 +1,104 @@
+import { t as temporal } from "./temporal-required-DqRzr7i0.js";
+import { t as defineController } from "./controller-D6NyNrlZ.js";
+import { t as sameRange } from "./range-DwpWe8e7.js";
+//#region src/blocks/bookings/event-calendar.ts
+/**
+* Bookings as event calendar events for a resource view (ReUI's Event
+* Calendar with `resources`, or a schedule): each booking sits on its
+* resource's row. Cancelled bookings are left out.
+*/
+function toEventCalendarBookings(bookings, options = {}) {
+	return bookings.flatMap((booking) => {
+		if (booking.status === "cancelled") return [];
+		const color = options.colorOf?.(booking);
+		return [{
+			id: booking.id,
+			title: options.titleOf?.(booking) ?? booking.customerName ?? "Booking",
+			start: new Date(booking.startsAt.epochMilliseconds),
+			end: new Date(booking.endsAt.epochMilliseconds),
+			resourceId: booking.resourceId,
+			...color === void 0 ? {} : { color },
+			...booking.status === "hold" ? { readOnly: true } : {},
+			data: booking
+		}];
+	});
+}
+/** Slots grouped by their local date (`YYYY-MM-DD`), in start order, for a day-by-day picker. */
+function slotsByDay(slots) {
+	const days = /* @__PURE__ */ new Map();
+	const sorted = slots.toSorted((a, b) => a.startsAt.epochMilliseconds - b.startsAt.epochMilliseconds);
+	for (const slot of sorted) {
+		const day = slot.localStart.toPlainDate().toString();
+		const list = days.get(day);
+		if (list === void 0) days.set(day, [slot]);
+		else list.push(slot);
+	}
+	return days;
+}
+//#endregion
+//#region src/blocks/bookings/client.ts
+const NO_DAYS = /* @__PURE__ */ new Map();
+/** The open slots of a service in the visible range, for a headless date and time picker. */
+function createAvailableSlotsController(options) {
+	const { client, serviceId, tz, resourceId, token } = options;
+	let range = options.range;
+	let ticket = 0;
+	return defineController({
+		slots: void 0,
+		days: NO_DAYS,
+		error: void 0,
+		loading: true
+	}, (state) => {
+		const refresh = async () => {
+			const request = ++ticket;
+			state.set({ loading: true });
+			const time = temporal();
+			const span = {
+				from: time.Instant.fromEpochMilliseconds(range.start.getTime()),
+				until: time.Instant.fromEpochMilliseconds(range.end.getTime())
+			};
+			const result = token === void 0 ? await client.availableSlots(serviceId, span, {
+				...tz === void 0 ? {} : { tz },
+				...resourceId === void 0 ? {} : { resourceId }
+			}) : await client.public.slots(token, span, tz === void 0 ? {} : { tz });
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				slots: result.data,
+				days: slotsByDay(result.data),
+				error: void 0,
+				loading: false
+			} : {
+				error: result.error,
+				loading: false
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				setRange: (next) => {
+					if (sameRange(range, next)) return;
+					range = next;
+					refresh();
+				},
+				hold: async (slot, customer) => {
+					const result = token === void 0 ? await client.hold(serviceId, slot.resourceId, slot.startsAt, customer) : await client.public.hold(token, slot.resourceId, slot.startsAt, {
+						...customer,
+						name: customer?.name ?? "",
+						email: customer?.email ?? ""
+					});
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					await refresh();
+					return result.data;
+				}
+			},
+			start: () => {
+				refresh();
+			}
+		};
+	});
+}
+//#endregion
+export { slotsByDay as n, toEventCalendarBookings as r, createAvailableSlotsController as t };

package/dist/client-DNq8xYb-.js

@@ -0,0 +1,52 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+//#region src/blocks/announcements/client.ts
+/**
+* The signed-in user's live announcements, loaded again whenever staff
+* publish, change or remove one.
+*/
+function createAnnouncementsController(options) {
+	const { client } = options;
+	const organizationId = options.organizationId ?? null;
+	const topic = options.topic === void 0 ? "announcements" : options.topic;
+	return defineController({
+		items: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const result = await client.listActive(organizationId);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				items: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: {
+				refresh,
+				dismiss: async (announcementId) => {
+					const result = await client.dismiss(announcementId);
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					state.set((current) => ({ items: current.items?.filter((item) => item.id !== announcementId) }));
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+				if (!topic) return;
+				return options.ports.topic(topic, {
+					onMessage: () => void refresh(),
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave;
+			})
+		};
+	});
+}
+//#endregion
+export { createAnnouncementsController as t };

package/dist/client-DR_YEGnc.d.ts

@@ -0,0 +1,130 @@
+import { E as ValidationIssue } from "./result-Cj3yWhjH.js";
+import { n as Controller } from "./controller-CCb9tHw_.js";
+import { a as FormDefinition, c as FormJson, d as FormStep, i as FormCondition, l as FormJsonSchema, o as FormField } from "./form-definition-sagoefQr.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/forms/validate.d.ts
+/** A submission's answers, by field key. */
+type FormAnswers = {
+  readonly [key: string]: FormJson;
+};
+/**
+ * Checks answers against a form version's schema with the keywords the
+ * generator emits, so a form can show errors before it submits. Postgres
+ * checks the same schema again on submit; this is not a general JSON
+ * Schema validator.
+ */
+declare function validateAnswers(schema: FormJsonSchema, answers: unknown): readonly ValidationIssue[];
+/** A form version's schema as a Standard Schema, for form libraries. */
+declare function answersSchema(schema: FormJsonSchema): StandardSchemaV1<unknown, FormAnswers>;
+//#endregion
+//#region src/blocks/forms/questionnaire.d.ts
+/** Whether `condition` holds for `answers`, with the semantics of its JSON Schema `if`. */
+declare function conditionHolds(condition: FormCondition | undefined, answers: FormAnswers): boolean;
+/** The steps whose `showIf` holds. */
+declare function visibleSteps(definition: FormDefinition, answers: FormAnswers): readonly FormStep[];
+/** The step's fields whose `showIf` holds. */
+declare function visibleFields(step: FormStep, answers: FormAnswers): readonly FormField[];
+/**
+ * The answers without the ones for hidden steps and fields. Removing an
+ * answer can hide a later field, so it repeats until nothing changes.
+ */
+declare function pruneAnswers(definition: FormDefinition, answers: FormAnswers): FormAnswers;
+/** The schema's issues for the fields `step` shows. */
+declare function stepIssues(schema: FormJsonSchema, step: FormStep, answers: FormAnswers): readonly ValidationIssue[];
+interface QuestionnaireState {
+  /** The step on screen, by key. */
+  readonly step: string;
+  readonly answers: FormAnswers;
+  /** The steps that passed their checks on `next`. */
+  readonly completed: readonly string[];
+  /** The issues of the step on screen after a `next` or `submit` that failed. */
+  readonly issues: readonly ValidationIssue[];
+}
+type QuestionnaireAction = {
+  readonly type: "answer";
+  readonly key: string;
+  readonly value: FormJson | undefined;
+} | {
+  readonly type: "next";
+} | {
+  readonly type: "back";
+} | {
+  readonly type: "goTo";
+  readonly step: string;
+} | {
+  readonly type: "reset";
+  readonly answers?: FormAnswers;
+};
+interface QuestionnaireForm {
+  readonly definition: FormDefinition;
+  /** The version's generated schema. */
+  readonly schema: FormJsonSchema;
+}
+/** The state before the first answer. */
+declare function initialQuestionnaire(form: QuestionnaireForm, answers?: FormAnswers): QuestionnaireState;
+/**
+ * The questionnaire as a reducer: answers, the current step and the steps
+ * done. `next` checks the step's fields against the version's schema and
+ * stays put with `issues` when one fails; hidden steps are skipped.
+ */
+declare function questionnaireReducer(form: QuestionnaireForm, state: QuestionnaireState, action: QuestionnaireAction): QuestionnaireState;
+interface QuestionnaireStepView {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly fields: readonly FormField[];
+  readonly completed: boolean;
+  readonly active: boolean;
+}
+/** The visible steps with their status, in the shape a Stepper renders. */
+declare function questionnaireSteps(form: QuestionnaireForm, state: QuestionnaireState): readonly QuestionnaireStepView[];
+/** The pruned answers, or every issue when the whole form does not pass. */
+declare function finishQuestionnaire(form: QuestionnaireForm, state: QuestionnaireState): {
+  readonly ok: true;
+  readonly answers: FormAnswers;
+} | {
+  readonly ok: false;
+  readonly issues: readonly ValidationIssue[];
+};
+//#endregion
+//#region src/blocks/forms/client.d.ts
+interface QuestionnaireOptions {
+  /** A form version, or anything with its `definition` and `schema`. */
+  readonly form: QuestionnaireForm;
+  /** Answers to start from, such as a saved draft. */
+  readonly initialAnswers?: FormAnswers;
+  /** Receives the answers of the visible fields once the whole form passes. */
+  readonly onSubmit: (answers: FormAnswers) => Promise<void> | void;
+}
+interface QuestionnaireSnapshot {
+  /** The visible steps, for a Stepper's items. */
+  readonly steps: readonly QuestionnaireStepView[];
+  /** The step on screen. */
+  readonly step: QuestionnaireStepView | undefined;
+  readonly answers: FormAnswers;
+  /** Issues by field key: the step on screen's after `next`, every field's after a failed `submit`. */
+  readonly issues: Readonly<Record<string, readonly string[]>>;
+  readonly isFirst: boolean;
+  readonly isLast: boolean;
+  readonly submitting: boolean;
+}
+interface QuestionnaireActions {
+  /** `undefined` removes the answer. */
+  readonly setAnswer: (key: string, value: FormJson | undefined) => void;
+  /** Checks the step and moves to the next visible one. */
+  readonly next: () => void;
+  readonly back: () => void;
+  /** Moves to a step whose earlier steps are done, for a clickable Stepper. */
+  readonly goTo: (step: string) => void;
+  /** Checks the whole form, then calls `onSubmit`. Returns whether it passed. */
+  readonly submit: () => Promise<boolean>;
+  readonly reset: (answers?: FormAnswers) => void;
+}
+type QuestionnaireController = Controller<QuestionnaireSnapshot, QuestionnaireActions>;
+/**
+ * A multi-step form over a form version: the visible steps, the answers,
+ * and per-field issues checked against the version's JSON Schema.
+ */
+declare function createQuestionnaireController(options: QuestionnaireOptions): QuestionnaireController;
+//#endregion
+export { visibleFields as _, createQuestionnaireController as a, answersSchema as b, QuestionnaireState as c, finishQuestionnaire as d, initialQuestionnaire as f, stepIssues as g, questionnaireSteps as h, QuestionnaireSnapshot as i, QuestionnaireStepView as l, questionnaireReducer as m, QuestionnaireController as n, QuestionnaireAction as o, pruneAnswers as p, QuestionnaireOptions as r, QuestionnaireForm as s, QuestionnaireActions as t, conditionHolds as u, visibleSteps as v, validateAnswers as x, FormAnswers as y };