better-supabase 0.13.0 → 0.14.0

package/dist/client-CwKsEl6q.js

@@ -0,0 +1,99 @@
+import { s as toDbError } from "./result-B3m7xtRY.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/api-keys/client.ts
+const newestFirst = (keys) => keys.toSorted((a, b) => b.createdAt.epochMilliseconds - a.createdAt.epochMilliseconds);
+/**
+* The API keys of an organization (or the caller's personal keys) for an API
+* keys table: `create` returns the token once, `revoke` revokes a key, and both
+* load the list again.
+*/
+function createApiKeysController(options) {
+	const { client, organizationId } = options;
+	return defineController({
+		keys: void 0,
+		creating: false,
+		created: void 0,
+		revoking: [],
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			const result = await client.list(organizationId ?? void 0);
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				keys: newestFirst(result.data),
+				error: void 0
+			} : { error: result.error });
+		};
+		const changed = async (change) => {
+			try {
+				await options.onChanged?.(change);
+			} catch (cause) {
+				state.set({ error: toDbError(cause) });
+			}
+		};
+		return {
+			actions: {
+				refresh,
+				dismiss: () => {
+					state.set({
+						created: void 0,
+						error: void 0
+					});
+				},
+				create: async (draft) => {
+					state.set({
+						creating: true,
+						created: void 0,
+						error: void 0
+					});
+					const result = await client.create(organizationId === null ? draft : {
+						...draft,
+						organizationId
+					});
+					state.set(result.ok ? {
+						creating: false,
+						created: result.data
+					} : {
+						creating: false,
+						error: result.error
+					});
+					if (result.ok) {
+						await refresh();
+						await changed({
+							kind: "created",
+							key: result.data.key
+						});
+					}
+					return result;
+				},
+				revoke: async (id) => {
+					state.set((current) => ({
+						revoking: [...current.revoking, id],
+						error: void 0
+					}));
+					const result = await client.revoke(id);
+					state.set((current) => ({
+						revoking: current.revoking.filter((each) => each !== id),
+						...result.ok ? {} : { error: result.error }
+					}));
+					if (result.ok) {
+						await refresh();
+						await changed({
+							kind: "revoked",
+							id
+						});
+					}
+					return result;
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
+export { createApiKeysController as t };

package/dist/client-D-LPdEDQ.d.ts

@@ -0,0 +1,43 @@
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+import { t as EntitlementClaimOptions } from "./entitlements-DDevu4ZE.js";
+//#region src/blocks/entitlements/client.d.ts
+interface FeatureGateControllerOptions {
+  readonly auth: AuthPort;
+  /** The plan feature, such as `exports`: a key of `entitlements.source.plans`. */
+  readonly feature: string;
+  /**
+   * The organization to check. Default the session's active one, from the
+   * tenant claim.
+   */
+  readonly organizationId?: string | null;
+  /**
+   * `config.claims.features` (default `features`), or `{ claim, keys }` for
+   * short codes.
+   */
+  readonly claim?: string | EntitlementClaimOptions;
+  /** The tenant claim, `config.claims.tenant` (default `tenant_id`). */
+  readonly tenantClaim?: string;
+}
+interface FeatureGateSnapshot {
+  /**
+   * `undefined` while the session loads; false when signed out or outside an
+   * organization.
+   */
+  readonly allowed: boolean | undefined;
+  /** The organization the check ran for. */
+  readonly organizationId: string | undefined;
+}
+interface FeatureGateActions {
+  /** Checks the session again, such as after a refresh the gate did not hear of. */
+  readonly recheck: () => void;
+}
+type FeatureGateController = Controller<FeatureGateSnapshot, FeatureGateActions>;
+/**
+ * Whether the active organization's plan includes `feature`, from the session's
+ * plan-features claim. It updates when the session does, so a session refresh
+ * after checkout opens the gate. UX only: enforce the feature in RLS with
+ * `better_supabase.has_entitlement()`.
+ */
+declare function createFeatureGateController(options: FeatureGateControllerOptions): FeatureGateController;
+//#endregion
+export { createFeatureGateController as a, FeatureGateSnapshot as i, FeatureGateController as n, FeatureGateControllerOptions as r, FeatureGateActions as t };

package/dist/client-D6gD9qt9.d.ts

@@ -0,0 +1,45 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+import { n as Controller } from "./controller-DAD4hbl4.js";
+import { f as Bookings, m as PlacedBooking, r as BookingCustomer, u as BookingSlot } from "./bookings-CC7IeiRa.js";
+import { t as VisibleRange } from "./range-p5V4rBhZ.js";
+//#region src/blocks/bookings/client.d.ts
+interface AvailableSlotsOptions {
+  readonly client: Pick<Bookings, "availableSlots" | "hold"> & {
+    readonly public: Pick<Bookings["public"], "slots" | "hold">;
+  };
+  readonly serviceId: string;
+  /** The visible range; `setRange` changes it. */
+  readonly range: VisibleRange;
+  /** The zone slot times are shown in. Default each resource's. */
+  readonly tz?: string;
+  readonly resourceId?: string;
+  /** A share-link token: loads and holds slots as a guest. */
+  readonly token?: string;
+}
+interface AvailableSlotsSnapshot {
+  /** `undefined` until the first load. */
+  readonly slots: readonly BookingSlot[] | undefined;
+  /** The slots by local date (`YYYY-MM-DD`), for a day-by-day picker. */
+  readonly days: ReadonlyMap<string, readonly BookingSlot[]>;
+  readonly error: DbError | undefined;
+  /** True until the slots of the current range arrive. */
+  readonly loading: boolean;
+}
+interface AvailableSlotsActions {
+  readonly refresh: () => Promise<void>;
+  /**
+   * Holds a slot, then loads the range again. With a token, `customer` needs a
+   * name and an email.
+   */
+  readonly hold: (slot: BookingSlot, customer?: BookingCustomer) => Promise<PlacedBooking | undefined>;
+  /** Shows another range; the current slots stay until its slots arrive. */
+  readonly setRange: (range: VisibleRange) => void;
+}
+type AvailableSlotsController = Controller<AvailableSlotsSnapshot, AvailableSlotsActions>;
+/**
+ * The open slots of a service in the visible range, for a headless date and
+ * time picker.
+ */
+declare function createAvailableSlotsController(options: AvailableSlotsOptions): AvailableSlotsController;
+//#endregion
+export { createAvailableSlotsController as a, AvailableSlotsSnapshot as i, AvailableSlotsController as n, AvailableSlotsOptions as r, AvailableSlotsActions as t };

package/dist/client-DBwWXQKF.d.ts

@@ -0,0 +1,132 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, b as DbError, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "./block-helpers-BaugZlJV.js";
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { p as SubscriptionStatus } from "./topic-D9j8G2dw.js";
+import { n as TopicPort } from "./watch-topic-CIT3UlAh.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/announcements/announcements.d.ts
+type AnnouncementSeverity = "info" | "success" | "warning" | "critical";
+/**
+ * Who sees it: everyone, members of some tenants, members with some roles, or
+ * tenants on some plans (entitlement lookup keys, with the entitlements
+ * module).
+ */
+type AnnouncementAudience = {
+  readonly type: "all";
+} | {
+  readonly type: "tenant";
+  readonly organizationIds: readonly string[];
+} | {
+  readonly type: "role";
+  readonly roles: readonly string[];
+} | {
+  readonly type: "plan";
+  readonly plans: readonly string[];
+};
+interface Announcement {
+  readonly id: string;
+  readonly title: string;
+  readonly body: string;
+  readonly severity: AnnouncementSeverity;
+  readonly href: string | undefined;
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant | undefined;
+  readonly dismissible: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** An announcement as staff see it, with its audience. */
+interface ManagedAnnouncement extends Announcement {
+  readonly audience: AnnouncementAudience;
+  readonly createdBy: string | undefined;
+}
+interface AnnouncementInput {
+  readonly title: string;
+  /** Plain text or Markdown; the app renders it. */
+  readonly body?: string;
+  readonly severity?: AnnouncementSeverity;
+  /** A link for "Learn more": `https://` or a path. */
+  readonly href?: string | null;
+  readonly audience?: AnnouncementAudience;
+  readonly startsAt?: Temporal.Instant;
+  readonly endsAt?: Temporal.Instant | null;
+  readonly dismissible?: boolean;
+}
+interface AnnouncementsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the announcement columns the app adds
+   * (`blocks.announcements.options.extraColumns`), keyed by column name. It
+   * types and parses them on every read, and validates them on `publish` and
+   * `update`, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Announcements<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** `F` is the extra fields `options.fields` describes. */
+interface Announcements<F extends object = Record<never, never>> {
+  /**
+   * The caller's live, undismissed announcements; pass the active tenant for
+   * tenant, role and plan audiences.
+   */
+  listActive(organizationId?: string | null): AsyncResult<readonly (Announcement & F)[]>;
+  /** Hides one for the caller; `false` when it was hidden already. */
+  dismiss(announcementId: string): AsyncResult<boolean>;
+  /** Every announcement; needs `announcements.manage` on the platform. */
+  list(): AsyncResult<readonly (ManagedAnnouncement & F)[]>;
+  /** Keys besides the input's own are the announcement's extra columns. */
+  publish(input: AnnouncementInput & Partial<F>): AsyncResult<ManagedAnnouncement & F>;
+  update(announcementId: string, input: Partial<AnnouncementInput> & Partial<F>): AsyncResult<ManagedAnnouncement & F>;
+  remove(announcementId: string): AsyncResult<boolean>;
+}
+declare function createAnnouncements<S extends StandardSchemaV1 | undefined = undefined>(options: AnnouncementsOptions<S>): Announcements<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/announcements/client.d.ts
+interface AnnouncementsControllerOptions {
+  readonly client: Pick<Announcements, "listActive" | "dismiss">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The active tenant, for tenant, role and plan audiences. */
+  readonly organizationId?: string | null;
+  /**
+   * The topic the module broadcasts to
+   * (`blockConfig.announcements.options.topic` from `blocks.generated.ts`);
+   * `null` loads once.
+   */
+  readonly topic?: string | null;
+}
+interface AnnouncementsSnapshot {
+  /** `undefined` until the first load. */
+  readonly items: readonly Announcement[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AnnouncementsActions {
+  /** Hides one for the user, then drops it from `items`. */
+  readonly dismiss: (announcementId: string) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+type AnnouncementsController = Controller<AnnouncementsSnapshot, AnnouncementsActions>;
+/**
+ * The signed-in user's live announcements, loaded again whenever staff publish,
+ * change or remove one.
+ */
+declare function createAnnouncementsController(options: AnnouncementsControllerOptions): AnnouncementsController;
+//#endregion
+export { createAnnouncementsController as a, AnnouncementInput as c, AnnouncementsOptions as d, ManagedAnnouncement as f, AnnouncementsSnapshot as i, AnnouncementSeverity as l, AnnouncementsController as n, Announcement as o, createAnnouncements as p, AnnouncementsControllerOptions as r, AnnouncementAudience as s, AnnouncementsActions as t, Announcements as u };

package/dist/client-DT6Tvudr.d.ts

@@ -0,0 +1,54 @@
+import { p as SubscriptionStatus } from "./topic-D9j8G2dw.js";
+import { n as TopicPort } from "./watch-topic-CIT3UlAh.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/notifications/client.d.ts
+/**
+ * Loads one list of items, e.g. a server action that calls
+ * `notifications.list()`.
+ */
+type NotificationSource<T> = () => Promise<readonly T[]>;
+interface NotificationFeedOptions<T> {
+  /**
+   * The private topic the `notifications` module broadcasts to:
+   * `fillTopic(blockConfig.notifications.options.topic, { userId })` with the
+   * template from `blocks.generated.ts`. `null` loads once without realtime.
+   */
+  readonly topic: string | null;
+  /** The notifications, newest first. */
+  readonly load: NotificationSource<T>;
+  /** More items merged in, such as running jobs or pending approvals. */
+  readonly sources?: readonly NotificationSource<T>[];
+  /** Orders the merged list. Defaults to the order the sources return. */
+  readonly sort?: (a: T, b: T) => number;
+  /** The badge number. Defaults to the items without a `readAt`. */
+  readonly count?: (items: readonly T[]) => number;
+  /** Runs for each broadcast, e.g. to show a toast for `notification_created`. */
+  readonly onMessage?: (event: string, payload: unknown) => void;
+}
+interface NotificationsControllerOptions<T> extends NotificationFeedOptions<T> {
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+}
+interface NotificationsSnapshot<T> {
+  /** `undefined` until the first load. */
+  readonly items: readonly T[] | undefined;
+  readonly count: number;
+  readonly status: SubscriptionStatus;
+  readonly error: unknown;
+}
+interface NotificationsActions {
+  /** Loads again, e.g. after marking items read. */
+  readonly refresh: () => Promise<void>;
+}
+type NotificationsController<T> = Controller<NotificationsSnapshot<T>, NotificationsActions>;
+/** The default badge number: the items whose `readAt` is `null`. */
+declare const unreadCount: (items: readonly unknown[]) => number;
+/**
+ * The signed-in user's notifications, kept current: loads them, then loads
+ * again after each broadcast on `topic` and after the channel rejoins.
+ */
+declare function createNotificationsController<T>(options: NotificationsControllerOptions<T>): NotificationsController<T>;
+//#endregion
+export { NotificationsControllerOptions as a, unreadCount as c, NotificationsController as i, NotificationSource as n, NotificationsSnapshot as o, NotificationsActions as r, createNotificationsController as s, NotificationFeedOptions as t };

package/dist/client-DU1_Jq4e.d.ts

@@ -0,0 +1,116 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+import { O as AiShareLink, a as AiChatInput, c as AiChatPatch, d as AiChatShare, h as AiModel, i as AiChat, k as AiStoredMessage, l as AiChatQuery, u as AiChatRecord } from "./ai-chat-DBxEz3o1.js";
+import { p as SubscriptionStatus } from "./topic-D9j8G2dw.js";
+import { n as TopicPort } from "./watch-topic-CIT3UlAh.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/ai-chat/client.d.ts
+interface Ports {
+  readonly topic: TopicPort;
+}
+interface AiChatsControllerOptions {
+  readonly client: Pick<AiChat, "chats">;
+  readonly auth: AuthPort;
+  readonly ports: Ports;
+  /** The list's filters and page size. */
+  readonly query?: Omit<AiChatQuery, "cursor">;
+  /**
+   * The prefix of the list topic (`blockConfig["ai-chat"].options.listTopic`
+   * from `blocks.generated.ts`); `null` loads once.
+   */
+  readonly topic?: string | null;
+}
+interface AiChatsSnapshot {
+  /** `undefined` until the first load. */
+  readonly items: readonly AiChatRecord[] | undefined;
+  /** Whether `loadMore` has another page. */
+  readonly hasMore: boolean;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AiChatsActions {
+  readonly loadMore: () => Promise<void>;
+  readonly refresh: () => Promise<void>;
+  readonly create: (input?: AiChatInput) => Promise<AiChatRecord | undefined>;
+  readonly update: (chatId: string, patch: AiChatPatch) => Promise<AiChatRecord | undefined>;
+  readonly remove: (chatId: string) => Promise<void>;
+}
+type AiChatsController = Controller<AiChatsSnapshot, AiChatsActions>;
+/**
+ * The signed-in user's chats in a tenant, newest first, loaded again when any
+ * of their chats changes. Pages loaded with `loadMore` load again too.
+ */
+declare function createAiChatsController(options: AiChatsControllerOptions): AiChatsController;
+interface AiChatTreeControllerOptions {
+  readonly client: {
+    readonly messages: Pick<AiChat["messages"], "path" | "switchBranch" | "siblings">;
+  };
+  readonly ports: Ports;
+  /** `null` or `undefined` waits. */
+  readonly chatId: string | null | undefined;
+  /**
+   * The prefix of the chat topic (`blockConfig["ai-chat"].options.topic` from
+   * `blocks.generated.ts`); `null` loads once.
+   */
+  readonly topic?: string | null;
+}
+interface AiChatTreeSnapshot {
+  /** The active branch, root first; `undefined` until the first load. */
+  readonly path: readonly AiStoredMessage[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AiChatTreeActions {
+  readonly refresh: () => Promise<void>;
+  /** Shows the branch through `messageId`. */
+  readonly switchBranch: (messageId: string) => Promise<void>;
+  /** Shows the sibling `offset` places from `messageId` (`-1` older, `1` newer). */
+  readonly step: (messageId: string, offset: number) => Promise<void>;
+}
+type AiChatTreeController = Controller<AiChatTreeSnapshot, AiChatTreeActions>;
+/**
+ * One chat's active branch, loaded again when a message is saved or the branch
+ * changes, in this tab or another.
+ */
+declare function createAiChatTreeController(options: AiChatTreeControllerOptions): AiChatTreeController;
+interface AiModelsControllerOptions {
+  readonly client: {
+    readonly models: Pick<AiChat["models"], "allowed">;
+  };
+  readonly organizationId?: string | null;
+}
+interface AiModelsSnapshot {
+  /** `undefined` until loaded. */
+  readonly models: readonly AiModel[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface AiModelsActions {
+  readonly refresh: () => Promise<void>;
+}
+type AiModelsController = Controller<AiModelsSnapshot, AiModelsActions>;
+/** The models the tenant's plans allow, for a model picker. */
+declare function createAiModelsController(options: AiModelsControllerOptions): AiModelsController;
+interface AiShareControllerOptions {
+  readonly client: {
+    readonly shares: Pick<AiChat["shares"], "list" | "create" | "revoke">;
+  };
+  /** `null` or `undefined` waits. */
+  readonly chatId: string | null | undefined;
+}
+interface AiShareSnapshot {
+  /** The chat's share links, newest first; `undefined` until loaded. */
+  readonly shares: readonly AiChatShare[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface AiShareActions {
+  /**
+   * Makes a link to the active branch, or to `leafId`; the token is in the
+   * result only.
+   */
+  readonly create: (leafId?: string) => Promise<AiShareLink | undefined>;
+  readonly revoke: (shareId: string) => Promise<void>;
+}
+type AiShareController = Controller<AiShareSnapshot, AiShareActions>;
+/** Share links for one chat the user owns. */
+declare function createAiShareController(options: AiShareControllerOptions): AiShareController;
+//#endregion
+export { createAiChatTreeController as _, AiChatsActions as a, createAiShareController as b, AiChatsSnapshot as c, AiModelsControllerOptions as d, AiModelsSnapshot as f, AiShareSnapshot as g, AiShareControllerOptions as h, AiChatTreeSnapshot as i, AiModelsActions as l, AiShareController as m, AiChatTreeController as n, AiChatsController as o, AiShareActions as p, AiChatTreeControllerOptions as r, AiChatsControllerOptions as s, AiChatTreeActions as t, AiModelsController as u, createAiChatsController as v, createAiModelsController as y };