better-supabase 0.13.0 → 0.14.0

package/dist/client-BgmVu505.js

@@ -0,0 +1,167 @@
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, k as recordsOf, n as applyTemporal, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+import { r as subjectKey, t as bySubjectType } from "./block-subjects-Dzq5Xn_0.js";
+import { t as requireTenant } from "./block-tenant-C1sNV8_4.js";
+//#region src/blocks/reactions/reactions.ts
+/** The topic the module broadcasts an organization's reaction changes to. */
+function reactionsTopic(organizationId, topic = "reactions") {
+	return `${topic}:${organizationId}`;
+}
+function countsOf(value, fn) {
+	return recordsOf(value, fn).map((row) => ({
+		emoji: textOf(row["emoji"]),
+		count: Number(row["count"]),
+		reacted: row["reacted"] === true,
+		actors: Array.isArray(row["actors"]) ? row["actors"].map((actor) => textOf(actor)) : []
+	}));
+}
+function voteOf(value) {
+	const vote = Number(value);
+	return vote === 1 || vote === -1 ? vote : 0;
+}
+function tallyOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		score: Number(row["score"] ?? 0),
+		up: Number(row["up"] ?? 0),
+		down: Number(row["down"] ?? 0),
+		vote: voteOf(row["vote"])
+	};
+}
+function emojiOf(value, fn) {
+	const row = recordOf(value, fn);
+	const attachmentId = optionalText(row["attachmentId"]);
+	const url = optionalText(row["url"]);
+	return {
+		id: textOf(row["id"]),
+		shortcode: textOf(row["shortcode"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...attachmentId === void 0 ? {} : { attachmentId },
+		...url === void 0 ? {} : { url }
+	};
+}
+/** The `reactions` SQL module as typed calls. */
+function createReactions(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const tenant = () => requireTenant(options.tenant);
+	return withBlockHooks({
+		react: (subject, emoji, react = {}) => tenant().andThen((organizationId) => call("react", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			emoji,
+			present: react.present ?? true,
+			actor: react.actor ?? null
+		}, (value) => countsOf(value, "react"))),
+		summary: (subjects) => tenant().andThen((organizationId) => bySubjectType(subjects, (type, ids) => call("reaction_summary", {
+			tenant: organizationId,
+			subject_type: type,
+			subject_ids: [...ids]
+		}, (value) => Object.fromEntries(Object.entries(recordOf(value, "reaction_summary")).map(([id, counts]) => [id, countsOf(counts, "reaction_summary")]))))),
+		vote: (subject, value, vote = {}) => tenant().andThen((organizationId) => call("vote", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			value,
+			actor: vote.actor ?? null
+		}, (result) => tallyOf(result, "vote"))),
+		votes: (subjects) => tenant().andThen((organizationId) => bySubjectType(subjects, (type, ids) => call("vote_summary", {
+			tenant: organizationId,
+			subject_type: type,
+			subject_ids: [...ids]
+		}, (value) => Object.fromEntries(Object.entries(recordOf(value, "vote_summary")).map(([id, tally]) => [id, tallyOf(tally, "vote_summary")]))))),
+		customEmoji: () => tenant().andThen((organizationId) => call("list_custom_emoji", { tenant: organizationId }, (value) => recordsOf(value, "list_custom_emoji").map((row) => emojiOf(row, "list_custom_emoji")))),
+		saveCustomEmoji: (input) => tenant().andThen((organizationId) => call("save_custom_emoji", {
+			tenant: organizationId,
+			shortcode: input.shortcode,
+			attachment_id: input.attachmentId ?? null,
+			url: input.url ?? null
+		}, (value) => emojiOf(value, "save_custom_emoji"))),
+		deleteCustomEmoji: (id) => call("delete_custom_emoji", { emoji_id: id }, (value) => value === true)
+	}, options.hooks, {
+		block: "reactions",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/reactions/client.ts
+const sameSubjects = (a, b) => a.length === b.length && a.every((subject, index) => {
+	const other = b[index];
+	return other !== void 0 && subject.type === other.type && subject.id === other.id;
+});
+/**
+* The reactions of the subjects on screen, loaded again when anyone in the
+* tenant reacts to one of them. `toggle` feeds an emoji picker.
+*/
+function createReactionsController(options) {
+	const { client, tenant } = options;
+	const topic = options.topic === void 0 ? "reactions" : options.topic;
+	let subjects = [...options.subjects];
+	let watching = false;
+	return defineController({
+		reactions: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			if (tenant === null) return;
+			ticket += 1;
+			const request = ticket;
+			const result = await client.summary(subjects);
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				reactions: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const watched = (payload) => typeof payload !== "object" || payload === null || !("subjectId" in payload) || !("subjectType" in payload) || subjects.some((subject) => subject.type === payload.subjectType && subject.id === payload.subjectId);
+		return {
+			actions: {
+				refresh,
+				setSubjects: (next) => {
+					if (sameSubjects(subjects, next)) return;
+					subjects = [...next];
+					if (watching) refresh();
+				},
+				toggle: async (subject, emoji) => {
+					const key = subjectKey(subject);
+					const present = !state.get().reactions?.[key]?.some((reaction) => reaction.emoji === emoji && reaction.reacted);
+					const result = await client.react(subject, emoji, { present });
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					state.set((current) => ({
+						error: void 0,
+						reactions: {
+							...current.reactions,
+							[key]: result.data
+						}
+					}));
+				}
+			},
+			start: () => tenant === null ? void 0 : whileSignedIn(options.auth, () => {
+				watching = true;
+				refresh();
+				const leave = topic ? options.ports.topic(reactionsTopic(tenant, topic), {
+					onMessage: (_event, payload) => {
+						if (watched(payload)) refresh();
+					},
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave : void 0;
+				return () => {
+					watching = false;
+					leave?.();
+				};
+			})
+		};
+	});
+}
+//#endregion
+export { createReactions as n, reactionsTopic as r, createReactionsController as t };

package/dist/client-Bj0xrUzr.js

@@ -0,0 +1,437 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as defineController } from "./controller-BEliOBOv.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+import { a as readAllFields, l as writeFields, n as blockFields, o as readFields, s as rowFields } from "./block-fields-DBSJSeaO.js";
+import { t as rankBetweenResult } from "./rank-result-C_sHjkiz.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-Bn0qqRBg.d.ts

@@ -0,0 +1,37 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+import { a as Usage, h as UsageStatus } from "./usage-DBcVGqnr.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/usage/client.d.ts
+interface UsageMeterControllerOptions {
+  /** `createUsage({ transport })`, or a `Pick` with `overview`. */
+  readonly client: Pick<Usage, "overview">;
+  readonly auth: AuthPort;
+  /** The organization whose usage to read; the meter waits without one. */
+  readonly organizationId: string | null;
+  /**
+   * Only these meters, in this order. Default every meter with usage or a
+   * quota.
+   */
+  readonly meters?: readonly string[];
+}
+/** One meter against its quota. */
+interface MeterReading extends UsageStatus {
+  /** `used / limit` from 0 to 1, or `undefined` without a limit. */
+  readonly fraction: number | undefined;
+  /** True once the period's quota is used up. */
+  readonly exceeded: boolean;
+}
+interface UsageMeterSnapshot {
+  /** `undefined` until the first load. */
+  readonly meters: readonly MeterReading[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface UsageMeterActions {
+  /** Reads the usage again, such as after the app records some. */
+  readonly refresh: () => Promise<void>;
+}
+type UsageMeterController = Controller<UsageMeterSnapshot, UsageMeterActions>;
+/** This period's usage of an organization against its plan's quotas, per meter. */
+declare function createUsageMeterController(options: UsageMeterControllerOptions): UsageMeterController;
+//#endregion
+export { UsageMeterSnapshot as a, UsageMeterControllerOptions as i, UsageMeterActions as n, createUsageMeterController as o, UsageMeterController as r, MeterReading as t };