better-supabase 0.8.0 → 0.10.0

package/dist/client-CmHsfDHU.js

@@ -0,0 +1,438 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { t as AsyncResult } from "./result-COkvI9t5.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as defineController } from "./controller-D6NyNrlZ.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "./block-helpers-BfVCR5Fc.js";
+import { r as withBlockHooks } from "./block-hooks-ByKlh8Qy.js";
+import { a as readAllFields, l as writeFields, n as blockFields, o as readFields, s as rowFields } from "./block-fields-BANwJ9Y_.js";
+import { t as rankBetweenResult } from "./rank-result-oUF1DYBm.js";
+//#region src/blocks/saved-views/saved-views.ts
+const SAVED_VIEW_KINDS = [
+	"table",
+	"board",
+	"calendar",
+	"timeline",
+	"gantt"
+];
+const SAVED_VIEW_SCOPES = [
+	"user",
+	"team",
+	"tenant"
+];
+const SAVED_VIEW_DENSITIES = [
+	"compact",
+	"default",
+	"comfortable"
+];
+const strings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function columnIssues(value) {
+	if (value === void 0) return [];
+	if (!isRecord(value)) return [{
+		message: "columns must be an object",
+		path: ["columns"]
+	}];
+	const issues = [];
+	for (const key of ["visible", "order"]) if (value[key] !== void 0 && !strings(value[key])) issues.push({
+		message: `columns.${key} must be a list of column ids`,
+		path: ["columns", key]
+	});
+	const sizes = value["sizes"];
+	if (sizes !== void 0 && !(isRecord(sizes) && Object.values(sizes).every(Number.isFinite))) issues.push({
+		message: "columns.sizes must map column ids to numbers",
+		path: ["columns", "sizes"]
+	});
+	const pinned = value["pinned"];
+	if (pinned !== void 0 && !(isRecord(pinned) && (pinned["left"] === void 0 || strings(pinned["left"])) && (pinned["right"] === void 0 || strings(pinned["right"])))) issues.push({
+		message: "columns.pinned must have left and right lists",
+		path: ["columns", "pinned"]
+	});
+	return issues;
+}
+/**
+* Checks a view's state, and its `query` against `list` when given. An
+* empty list means the state is valid.
+*/
+function savedViewIssues(state, list) {
+	if (!isRecord(state)) return [{ message: "state must be an object" }];
+	const issues = columnIssues(state["columns"]);
+	if (state["grouping"] !== void 0 && !strings(state["grouping"])) issues.push({
+		message: "grouping must be a list of column ids",
+		path: ["grouping"]
+	});
+	const density = state["density"];
+	if (density !== void 0 && !SAVED_VIEW_DENSITIES.some((item) => item === density)) issues.push({
+		message: `density must be one of ${SAVED_VIEW_DENSITIES.join(", ")}`,
+		path: ["density"]
+	});
+	if (state["layout"] !== void 0 && !isRecord(state["layout"])) issues.push({
+		message: "layout must be an object",
+		path: ["layout"]
+	});
+	if (state["collectionId"] !== void 0 && typeof state["collectionId"] !== "string") issues.push({
+		message: "collectionId must be a collection id",
+		path: ["collectionId"]
+	});
+	const query = state["query"];
+	if (query !== void 0) {
+		if (!isRecord(query)) issues.push({
+			message: "query must be an object",
+			path: ["query"]
+		});
+		else if (list) {
+			const parsed = list.parse(withoutPage(query));
+			for (const issue of parsed.ok ? [] : parsed.issues ?? []) issues.push({
+				message: issue.message,
+				path: ["query", ...issue.path ?? []]
+			});
+		}
+	}
+	return issues;
+}
+/** The JSON Schema of a view's state, with `query` from the list's schema. */
+function savedViewStateSchema(list) {
+	const ids = {
+		type: "array",
+		items: { type: "string" }
+	};
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		type: "object",
+		properties: {
+			query: list ? list.jsonSchema : { type: "object" },
+			columns: {
+				type: "object",
+				properties: {
+					visible: ids,
+					order: ids,
+					sizes: {
+						type: "object",
+						additionalProperties: { type: "number" }
+					},
+					pinned: {
+						type: "object",
+						properties: {
+							left: ids,
+							right: ids
+						},
+						additionalProperties: false
+					}
+				},
+				additionalProperties: false
+			},
+			grouping: ids,
+			density: { enum: [...SAVED_VIEW_DENSITIES] },
+			layout: { type: "object" },
+			collectionId: {
+				type: "string",
+				format: "uuid"
+			}
+		}
+	};
+}
+function storedState(state) {
+	if (!state.query) return { ...state };
+	return {
+		...state,
+		query: withoutPage(state.query)
+	};
+}
+function withoutPage(query) {
+	return Object.fromEntries(Object.entries(query).filter(([key]) => key !== "page" && key !== "after"));
+}
+function oneOfOr(values, value, fallback) {
+	return values.find((item) => item === value) ?? fallback;
+}
+function preferenceOf(value) {
+	const row = isRecord(value) ? value : {};
+	return {
+		isDefault: row["isDefault"] === true,
+		hidden: row["hidden"] === true,
+		pinned: row["pinned"] === true
+	};
+}
+function savedOf(value) {
+	const row = recordOf(value, "saved view");
+	return {
+		id: textOf(row["id"]),
+		rank: textOf(row["rank"]),
+		fields: rowFields(row["fields"])
+	};
+}
+function viewOf(value) {
+	const row = recordOf(value, "saved view");
+	const state = row["state"];
+	return {
+		id: textOf(row["id"]),
+		list: textOf(row["list"]),
+		scope: oneOfOr(SAVED_VIEW_SCOPES, row["scope"], "user"),
+		ownerId: optionalText(row["ownerId"]) ?? null,
+		teamId: optionalText(row["teamId"]) ?? null,
+		name: textOf(row["name"]),
+		kind: oneOfOr(SAVED_VIEW_KINDS, row["kind"], "table"),
+		state: isRecord(state) ? state : {},
+		rank: optionalText(row["rank"]) ?? "V",
+		isDefault: row["isDefault"] === true,
+		preference: preferenceOf(row["preference"]),
+		fields: rowFields(row["fields"])
+	};
+}
+function createSavedViews(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "saved view fields");
+	return withBlockHooks({
+		save: (input) => {
+			const issues = savedViewIssues(input.state, options.lists?.[input.list]);
+			if (issues.length > 0) return AsyncResult.err(dbError("validation", "the saved view's state is not valid", { issues }));
+			return writeFields(fields, input.fields, (checked) => call("save_view", {
+				tenant: input.organizationId,
+				list: input.list,
+				name: input.name,
+				kind: input.kind ?? "table",
+				scope: input.scope ?? "user",
+				team: input.teamId ?? null,
+				state: storedState(input.state),
+				view_id: input.id ?? null,
+				fields: checked
+			}, savedOf)).andThen((saved) => readFields(fields, saved));
+		},
+		list: (organizationId, list) => call("list_views", {
+			tenant: organizationId,
+			list
+		}, (value) => recordsOf(value, "list_views").map(viewOf)).andThen((views) => readAllFields(fields, views)),
+		reorder: (id, neighbors) => {
+			const key = rankBetweenResult(neighbors);
+			if (!key.ok) return AsyncResult.err(key.error);
+			return call("rank_view", {
+				view_id: id,
+				rank: key.data
+			}, () => key.data);
+		},
+		setDefault: (id, on = true) => call("set_default_view", {
+			view_id: id,
+			on_default: on
+		}, (value) => value === true),
+		setPreference: (id, preference) => call("set_view_preference", {
+			view_id: id,
+			make_default: preference.isDefault ?? null,
+			hide: preference.hidden ?? null,
+			pin: preference.pinned ?? null
+		}, preferenceOf),
+		duplicate: (id, input = {}) => call("duplicate_view", {
+			view_id: id,
+			scope: input.scope ?? "user",
+			name: input.name ?? null,
+			team: input.teamId ?? null
+		}, savedOf).andThen((saved) => readFields(fields, saved)),
+		delete: (id) => call("delete_view", { view_id: id }, (value) => value === true)
+	}, options.hooks, {
+		block: "saved-views",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/**
+* The view that opens first: the caller's preferred default, then the
+* user's slot default, a team default, the tenant's, then the first view.
+* Views the caller hid are skipped.
+*/
+function defaultView(views) {
+	const shown = views.filter((view) => view.preference?.hidden !== true);
+	const preferred = shown.find((view) => view.preference?.isDefault === true);
+	if (preferred) return preferred;
+	for (const scope of SAVED_VIEW_SCOPES) {
+		const match = shown.find((view) => view.isDefault && view.scope === scope);
+		if (match) return match;
+	}
+	return shown[0];
+}
+//#endregion
+//#region src/blocks/saved-views/query-state.ts
+const RESERVED = /* @__PURE__ */ new Set([
+	"q",
+	"sort",
+	"page",
+	"after",
+	"size",
+	"filter"
+]);
+const isStrings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const isFilter = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A list's URL state as the typed query a view stores, without the page. */
+function queryFromUrlState(state) {
+	const facets = {};
+	for (const [key, value] of Object.entries(state)) if (!RESERVED.has(key) && isStrings(value) && value.length > 0) facets[key] = value;
+	const q = state["q"];
+	const sort = state["sort"];
+	const size = state["size"];
+	const filter = state["filter"];
+	return {
+		...typeof q === "string" && q !== "" && { q },
+		...typeof sort === "string" && { sort },
+		...typeof size === "number" && { size },
+		...isFilter(filter) && { filter },
+		...Object.keys(facets).length > 0 && { facets }
+	};
+}
+/**
+* The URL state that opens a view's query: every key in `keys` (the
+* current state's), `null` unless the query sets it, so applying a view
+* clears what the previous one set. The page goes back to the first.
+*/
+function urlStateFromQuery(query, keys) {
+	const facets = query?.facets ?? {};
+	const next = {};
+	for (const key of keys) switch (key) {
+		case "q":
+			next[key] = query?.q ?? null;
+			break;
+		case "sort":
+			next[key] = query?.sort ?? null;
+			break;
+		case "size":
+			next[key] = query?.size ?? null;
+			break;
+		case "filter":
+			next[key] = query?.filter ?? null;
+			break;
+		case "page":
+		case "after":
+			next[key] = null;
+			break;
+		default: next[key] = facets[key]?.length ? facets[key] : null;
+	}
+	return next;
+}
+function canonical(value) {
+	if (Array.isArray(value)) return value.map(canonical);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0 && item !== null).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)]));
+	return value;
+}
+/** A view's state without `query`: the part `onApplyState` shows. */
+function displayStateOf(state) {
+	const { query: _query, ...display } = state;
+	return display;
+}
+/** Whether two states show the same columns, grouping, density and layout. */
+function sameDisplayState(a, b) {
+	const strip = (state) => canonical(state ? displayStateOf(state) : {});
+	return JSON.stringify(strip(a)) === JSON.stringify(strip(b));
+}
+/** Whether two stored queries select the same rows in the same order. */
+function sameQuery(a, b) {
+	const strip = (query) => {
+		if (!query) return {};
+		const { page: _page, after: _after, facets, ...rest } = query;
+		const kept = Object.entries(facets ?? {}).filter(([, values]) => values !== void 0 && values.length > 0);
+		return canonical(kept.length > 0 ? {
+			...rest,
+			facets: Object.fromEntries(kept)
+		} : rest);
+	};
+	return JSON.stringify(strip(a)) === JSON.stringify(strip(b));
+}
+//#endregion
+//#region src/blocks/saved-views/client.ts
+/** Matches the URL state and the display state against the loaded views. */
+function matchSavedViews(snapshot, urlState, display) {
+	const query = queryFromUrlState(urlState);
+	const shows = (view) => sameQuery(view.state.query, query) && (display === void 0 || sameDisplayState(view.state, display));
+	return {
+		active: snapshot.views?.find(shows),
+		query,
+		state: {
+			...display,
+			query
+		},
+		isDirty: snapshot.opened !== void 0 && !shows(snapshot.opened)
+	};
+}
+function needs(value, name) {
+	if (value === void 0) throw new Error(`better-supabase: saved views need \`${name}\``);
+	return value;
+}
+/**
+* Saved views of one list, synced with its URL state and, through
+* `getState` and `onApplyState`, with the table's columns, grouping,
+* density and layout.
+*/
+function createSavedViewsController(options) {
+	return defineController({
+		views: void 0,
+		opened: void 0,
+		error: void 0
+	}, (state) => {
+		const apply = (view) => {
+			state.set({ opened: view });
+			options.setUrlState(urlStateFromQuery(view.state.query, Object.keys(options.urlState())));
+			options.onApplyState?.(displayStateOf(view.state), view);
+		};
+		const refresh = async () => {
+			try {
+				state.set({
+					views: await options.load(),
+					error: void 0
+				});
+			} catch (cause) {
+				state.set({ error: cause });
+			}
+		};
+		return {
+			actions: {
+				apply,
+				refresh,
+				saveCurrent: async (name, id) => {
+					const save = needs(options.save, "save");
+					const query = queryFromUrlState(options.urlState());
+					await save({
+						name,
+						query,
+						state: {
+							...options.getState?.(),
+							query
+						},
+						...id !== void 0 && { id }
+					});
+					await refresh();
+				},
+				remove: async (id) => {
+					await needs(options.remove, "remove")(id);
+					state.set((current) => ({ opened: current.opened?.id === id ? void 0 : current.opened }));
+					await refresh();
+				},
+				duplicate: async (id, name, scope) => {
+					await needs(options.duplicate, "duplicate")({
+						id,
+						name,
+						...scope !== void 0 && { scope }
+					});
+					await refresh();
+				},
+				setPreference: async (id, preference) => {
+					await needs(options.setPreference, "setPreference")(id, preference);
+					await refresh();
+				}
+			},
+			start: () => {
+				if (state.get().views !== void 0) return;
+				const run = state.run();
+				(async () => {
+					try {
+						const loaded = await options.load();
+						if (run !== state.run()) return;
+						state.set({
+							views: loaded,
+							error: void 0
+						});
+						if (options.openDefault !== false && sameQuery(queryFromUrlState(options.urlState()), void 0)) {
+							const first = defaultView(loaded.filter((view) => view.isDefault || view.preference?.isDefault === true));
+							if (first) apply(first);
+						}
+					} catch (cause) {
+						if (run === state.run()) state.set({ error: cause });
+					}
+				})();
+			}
+		};
+	});
+}
+//#endregion
+export { sameDisplayState as a, SAVED_VIEW_DENSITIES as c, createSavedViews as d, defaultView as f, queryFromUrlState as i, SAVED_VIEW_KINDS as l, savedViewStateSchema as m, matchSavedViews as n, sameQuery as o, savedViewIssues as p, displayStateOf as r, urlStateFromQuery as s, createSavedViewsController as t, SAVED_VIEW_SCOPES as u };

package/dist/client-CpMv4-v5.d.ts

@@ -0,0 +1,100 @@
+import { p as SubscriptionStatus } from "./topic-Dgs-eSYQ.js";
+import { n as TopicPort } from "./watch-topic-D-rpUg5n.js";
+import { l as StoragePort } from "./ports-Dcnuo3HT.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/inbox/client.d.ts
+/** Loads one list, e.g. a server action that calls `inbox.conversations.list()`. */
+type InboxSource<T> = () => Promise<readonly T[]>;
+interface InboxListSnapshot<T> {
+  /** `undefined` until the first load. */
+  readonly items: readonly T[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: unknown;
+}
+interface InboxListActions {
+  readonly refresh: () => Promise<void>;
+}
+interface Ports {
+  readonly topic: TopicPort;
+}
+interface InboxControllerOptions<T> {
+  readonly auth: AuthPort;
+  readonly ports: Ports;
+  /** The organization; the controller joins `inbox:org:<id>`. `null` waits. */
+  readonly organizationId: string | null;
+  readonly load: InboxSource<T>;
+  /** `blockConfig.inbox.options.topic` from `blocks.generated.ts`. Defaults to `inbox`. */
+  readonly topic?: string;
+  /** Runs for each broadcast, e.g. to show a toast for `message`. */
+  readonly onMessage?: (event: string, payload: unknown) => void;
+}
+type InboxController<T> = Controller<InboxListSnapshot<T>, InboxListActions>;
+/**
+ * The staff view of an organization's conversations, kept current: loads,
+ * then loads again after each ping on `inbox:org:<id>` and on rejoin.
+ */
+declare function createInboxController<T>(options: InboxControllerOptions<T>): InboxController<T>;
+interface ConversationSnapshot<T> extends InboxListSnapshot<T> {
+  /** User ids typing now, the caller left out. */
+  readonly typing: readonly string[];
+}
+interface ConversationActions extends InboxListActions {
+  /** Tells the others the caller is typing; call it on input, throttled. */
+  readonly setTyping: (typing: boolean) => void;
+}
+interface ConversationControllerOptions<T> {
+  readonly auth: AuthPort;
+  readonly ports: Ports;
+  /** `null` waits, e.g. before the widget opens a conversation. */
+  readonly conversationId: string | null;
+  /** The messages, oldest first. */
+  readonly load: InboxSource<T>;
+  readonly topic?: string;
+  /** How long a typing ping counts. Defaults to 5000 ms. */
+  readonly typingMs?: number;
+}
+type ConversationController<T> = Controller<ConversationSnapshot<T>, ConversationActions>;
+/**
+ * One conversation's messages, kept current over `inbox:<id>`, with typing
+ * pings between staff and the contact. Notes never reach this topic.
+ */
+declare function createConversationController<T>(options: ConversationControllerOptions<T>): ConversationController<T>;
+interface InboxWidgetControllerOptions<T> {
+  readonly auth: AuthPort;
+  readonly ports: Ports & {
+    readonly storage?: StoragePort;
+  };
+  /**
+   * Opens the visitor's conversation, e.g. a server action that calls
+   * `inbox.conversations.open(inboxId, { message })` with the visitor's
+   * transport. Returns its id.
+   */
+  readonly open: (message: string) => Promise<string>;
+  /** Sends into the open conversation. */
+  readonly send: (conversationId: string, message: string) => Promise<void>;
+  readonly load: (conversationId: string) => Promise<readonly T[]>;
+  /**
+   * Remembers the conversation across reloads in the storage port.
+   * Defaults to `better-supabase:inbox-widget`; `null` forgets it.
+   */
+  readonly storageKey?: string | null;
+  readonly topic?: string;
+}
+interface InboxWidgetSnapshot<T> extends ConversationSnapshot<T> {
+  readonly conversationId: string | null;
+}
+interface InboxWidgetActions extends ConversationActions {
+  /** Opens the conversation with the first message, or sends into it. */
+  readonly submit: (message: string) => Promise<void>;
+  /** Forgets the conversation, so the next message opens a new one. */
+  readonly reset: () => void;
+}
+type InboxWidgetController<T> = Controller<InboxWidgetSnapshot<T>, InboxWidgetActions>;
+/**
+ * The visitor side of an in-app inbox: the first message opens the
+ * conversation, later ones go into it, and the messages and typing pings
+ * stay current. Visitors without an account sign in anonymously first.
+ */
+declare function createInboxWidgetController<T>(options: InboxWidgetControllerOptions<T>): InboxWidgetController<T>;
+//#endregion
+export { InboxController as a, InboxListSnapshot as c, InboxWidgetController as d, InboxWidgetControllerOptions as f, createInboxWidgetController as g, createInboxController as h, ConversationSnapshot as i, InboxSource as l, createConversationController as m, ConversationController as n, InboxControllerOptions as o, InboxWidgetSnapshot as p, ConversationControllerOptions as r, InboxListActions as s, ConversationActions as t, InboxWidgetActions as u };

package/dist/client-CsRpAyIv.d.ts

@@ -0,0 +1,68 @@
+import { b as DbError, f as Result } from "./result-Cj3yWhjH.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/billing/client.d.ts
+/** A plan the picker lists: a key from the app's plan catalog, plus whatever the app shows. */
+interface PlanOption {
+  readonly key: string;
+  readonly name: string;
+}
+/** The plans to offer and the tenant's current plan. */
+interface PlanCatalog<P> {
+  readonly plans: readonly P[];
+  /** The key of the tenant's current plan, `undefined` without a subscription. */
+  readonly current: string | undefined;
+}
+/** Where Checkout continues: Stripe's hosted page, or `undefined` when the server finished the change itself. */
+interface CheckoutStarted {
+  readonly url: string | undefined;
+}
+interface PlanPickerControllerOptions<P extends {
+  readonly key: string;
+} = PlanOption> {
+  readonly auth: AuthPort;
+  /**
+   * The plans and the current one, such as a server action that reads the
+   * app's plan catalog and the tenant's subscription. It throws on failure.
+   */
+  readonly load: () => Promise<PlanCatalog<P>>;
+  /** What a server already loaded: the first load is skipped. */
+  readonly initial?: PlanCatalog<P>;
+  /**
+   * Starts Checkout for a plan key on the server, such as a server action
+   * that calls `billing.checkout()`. The controller never talks to Stripe:
+   * the secret key stays on the server.
+   */
+  readonly checkout: (plan: string) => Promise<Result<CheckoutStarted>>;
+  /**
+   * Opens the Checkout URL: `location.assign(url)` on the web,
+   * `WebBrowser.openBrowserAsync(url)` from `expo-web-browser` in React Native.
+   */
+  readonly open: (url: string) => void | Promise<void>;
+}
+interface PlanPickerSnapshot<P> {
+  /** `undefined` until the first load. */
+  readonly plans: readonly P[] | undefined;
+  readonly current: string | undefined;
+  /** The plan whose Checkout is starting. */
+  readonly pending: string | undefined;
+  readonly error: DbError | undefined;
+}
+interface PlanPickerActions {
+  /**
+   * Starts Checkout for `plan` and opens its URL; a failure is also kept in
+   * `error`. Choosing the current plan does nothing.
+   */
+  readonly choose: (plan: string) => Promise<Result<CheckoutStarted>>;
+  readonly refresh: () => Promise<void>;
+}
+type PlanPickerController<P> = Controller<PlanPickerSnapshot<P>, PlanPickerActions>;
+/**
+ * The plans with the tenant's current one, for a plan picker: `choose`
+ * starts Checkout through the injected server action and opens the URL it
+ * returns.
+ */
+declare function createPlanPickerController<P extends {
+  readonly key: string;
+} = PlanOption>(options: PlanPickerControllerOptions<P>): PlanPickerController<P>;
+//#endregion
+export { PlanPickerController as a, createPlanPickerController as c, PlanPickerActions as i, PlanCatalog as n, PlanPickerControllerOptions as o, PlanOption as r, PlanPickerSnapshot as s, CheckoutStarted as t };