better-supabase 0.13.0 → 0.14.0

package/dist/client-C_0XZieg.js

@@ -0,0 +1,287 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { i as specKey, n as claimedTenant, r as sessionUserId, t as hasAuthModule } from "./auth-module-BEFESDC4.js";
+import { r as invalidateTables } from "./user-change-CSR_prhd.js";
+import { n as liveQuery, t as liveCount } from "./live-CZtRMh62.js";
+//#region src/bindings/client.ts
+/** The caller of the client's auth store. */
+function callerOf(auth) {
+	return {
+		status: auth.status,
+		userId: auth.user?.id ?? null
+	};
+}
+/**
+* The caller of a plain supabase-js client, for subscriptions made without the
+* provider. `loading` until auth-js reports the first state.
+*/
+function plainCaller(supabase) {
+	let caller = {
+		status: "loading",
+		userId: null
+	};
+	return {
+		current: () => caller,
+		subscribe: (listener) => {
+			if (!hasAuthModule(supabase)) {
+				caller = {
+					status: "signed-out",
+					userId: null
+				};
+				return () => void 0;
+			}
+			const { data } = supabase.auth.onAuthStateChange((_event, session) => {
+				caller = {
+					status: session ? "signed-in" : "signed-out",
+					userId: session ? sessionUserId(session) : null
+				};
+				listener();
+			});
+			return () => {
+				data.subscription.unsubscribe();
+			};
+		}
+	};
+}
+/** Throws when `invalidate` has no query client to refetch with. */
+function assertInvalidateClient(hook, options, queryClient) {
+	if (options?.invalidate && !queryClient) throw new Error(`better-supabase: ${hook}({ invalidate }) needs a queryClient on the provider or in the options`);
+}
+/**
+* Subscribes to a topic by its rendered name. Returns the function that leaves,
+* or `undefined` when the name does not match the topic.
+*/
+function startBroadcast(run) {
+	const matched = run.topic.match(run.name);
+	if (!matched) return;
+	const { queryClient } = run;
+	const forward = (payload, message) => {
+		const current = run.latest();
+		const table = current.handlers;
+		(table?.[message.event] ?? table?.["*"])?.(payload, message);
+		const invalidate = current.options?.invalidate;
+		if (!invalidate || !queryClient) return;
+		if (typeof invalidate !== "function") {
+			invalidateTables(queryClient, invalidate);
+			return;
+		}
+		for (const queryKey of invalidate(message)) queryClient.invalidateQueries({ queryKey });
+	};
+	const self = run.latest().options?.self;
+	const subscription = run.topic.subscribe(run.supabase, matched, { "*": forward }, {
+		...self === void 0 ? {} : { self },
+		onStatus: run.onStatus,
+		onInvalid: (message, issues) => run.latest().options?.onInvalid?.(message, issues)
+	});
+	return () => {
+		subscription.unsubscribe();
+		run.onStatus("closed");
+	};
+}
+/** The key a live subscription restarts on: spec, tenant and caller. */
+function liveKey(client, spec, auth, options) {
+	if (!spec || auth.status === "loading") return null;
+	const tenant = options.tenant ?? claimedTenant(auth, client.betterSupabase.meta);
+	return JSON.stringify([
+		specKey(spec),
+		tenant ?? null,
+		auth.user?.id ?? null,
+		options.debounceMs ?? null
+	]);
+}
+/** Invalidates the cached queries that read a table whenever one changes. */
+function startLiveQuery(run) {
+	const { client, queryClient, options } = run;
+	const tenant = options.tenant ?? claimedTenant(run.auth, client.betterSupabase.meta);
+	const userId = run.auth.user?.id ?? null;
+	const live = liveQuery(client.betterSupabase, client.supabase, run.spec, {
+		onChange: (tables) => void invalidateTables(queryClient, tables),
+		onStatus: run.onStatus,
+		...tenant === void 0 ? {} : { tenant },
+		...userId === null ? {} : { user: userId },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+	});
+	if (run.resumed) live.ready.then(() => void invalidateTables(queryClient, live.tables), () => void 0);
+	return () => {
+		live.unsubscribe();
+	};
+}
+/** Splits a count source into its spec and the seed's count and time. */
+function countSource(source, options) {
+	const seed = source && "spec" in source ? source : void 0;
+	return {
+		spec: (seed ? seed.spec : source) ?? null,
+		initial: seed?.count ?? options.initial,
+		seedAt: seed?.at,
+		seeded: seed !== void 0 && seed.count !== null
+	};
+}
+const NO_COUNT = {
+	key: null,
+	count: void 0,
+	at: 0,
+	error: void 0
+};
+/** Refetches the count after each debounced change to a table it reads. */
+function startLiveCount(run) {
+	const { client, key, options } = run;
+	const tenant = options.tenant ?? claimedTenant(run.auth, client.betterSupabase.meta);
+	const userId = run.auth.user?.id ?? null;
+	const live = liveCount(client.betterSupabase, client.supabase, client.db, run.spec, {
+		immediate: run.immediate,
+		...run.since === void 0 ? {} : { since: run.since },
+		onCount: (count) => {
+			const at = Date.now();
+			run.onState(() => ({
+				key,
+				count,
+				at,
+				error: void 0
+			}));
+		},
+		onError: (error) => {
+			run.onState((last) => ({
+				key,
+				count: last.key === key ? last.count : void 0,
+				at: last.key === key ? last.at : 0,
+				error
+			}));
+		},
+		onStatus: run.onStatus,
+		...tenant === void 0 ? {} : { tenant },
+		...userId === null ? {} : { user: userId },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+	});
+	return () => {
+		live.unsubscribe();
+	};
+}
+/** The count to show: the client's, unless a newer server seed arrived. */
+function shownCount(state, key, source) {
+	const fresh = state.key === key;
+	const seedNewer = source.seedAt !== void 0 && source.seeded && source.seedAt > state.at;
+	return {
+		count: fresh && state.count !== void 0 && !seedNewer ? state.count : source.initial,
+		error: fresh ? state.error : void 0
+	};
+}
+const NO_HANDLERS = {};
+/**
+* Joins a presence topic by its rendered name, or `undefined` when it does not
+* match.
+*/
+function joinPresence(supabase, topic, name, handlers) {
+	const matched = topic.match(name);
+	if (!matched) return;
+	const joined = topic.subscribe(supabase, matched, NO_HANDLERS, handlers);
+	let tracked;
+	return {
+		track: async (state) => {
+			const result = await joined.track(state);
+			return result.ok ? void 0 : result.error;
+		},
+		untrack: async () => {
+			const result = await joined.untrack();
+			return result.ok ? void 0 : result.error;
+		},
+		sync(state) {
+			const key = state === void 0 ? void 0 : JSON.stringify(state);
+			if (key === void 0 || key === tracked) return;
+			tracked = key;
+			if (state === null || state === void 0) joined.untrack();
+			else joined.track(state);
+		},
+		leave() {
+			joined.unsubscribe();
+		}
+	};
+}
+/** The error `track` and `untrack` return before the join. */
+const notJoined = () => Promise.resolve(dbError("invalid_request", "better-supabase: the presence topic is not joined"));
+/**
+* Tracks the runs of an action outside React: the inputs in flight, the last
+* data and the last error. `latest` is read on each run, so the action and the
+* callbacks can change between runs.
+*/
+function createActionRunner(latest) {
+	const listeners = /* @__PURE__ */ new Set();
+	let inFlight = [];
+	let data;
+	let error;
+	let state = snapshot();
+	function snapshot() {
+		const pendingInputs = inFlight.map((item) => item.input);
+		return {
+			pending: inFlight.length > 0,
+			pendingInputs,
+			pendingInput: pendingInputs.at(-1),
+			data,
+			error
+		};
+	}
+	const emit = () => {
+		state = snapshot();
+		for (const listener of listeners) listener();
+	};
+	return {
+		current: () => state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		run: async (input) => {
+			const entry = { input };
+			inFlight = [...inFlight, entry];
+			error = void 0;
+			emit();
+			const done = () => {
+				inFlight = inFlight.filter((item) => item !== entry);
+			};
+			const { action, options } = latest();
+			let result;
+			try {
+				result = await action(input);
+			} catch (cause) {
+				done();
+				emit();
+				throw cause;
+			}
+			done();
+			if (result.ok) data = result.data;
+			else error = result.error;
+			emit();
+			if (result.ok) options.onSuccess?.(result.data, input);
+			else options.onError?.(result.error, input);
+			return result;
+		},
+		reset: () => {
+			data = void 0;
+			error = void 0;
+			emit();
+		}
+	};
+}
+/**
+* One run per key: `update` restarts `start` when the key changes and stops the
+* run when the key is `null`.
+*/
+function keyed() {
+	let current;
+	return {
+		update: (key, start) => {
+			if (current?.key === key) return;
+			current?.stop?.();
+			current = key === null ? void 0 : {
+				key,
+				stop: start()
+			};
+		},
+		stop: () => {
+			current?.stop?.();
+			current = void 0;
+		}
+	};
+}
+//#endregion
+export { createActionRunner as a, liveKey as c, shownCount as d, startBroadcast as f, countSource as i, notJoined as l, startLiveQuery as m, assertInvalidateClient as n, joinPresence as o, startLiveCount as p, callerOf as r, keyed as s, NO_COUNT as t, plainCaller as u };

package/dist/client-ChOJ4v0D.js

@@ -0,0 +1,137 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { r as err } from "./result-B3m7xtRY.js";
+import { n as isRecord, t as isList } from "./guards-6F2bCtQR.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/settings/client.ts
+const isConverter = (value) => isRecord(value) && typeof value["input"] === "function";
+const jsonSchemaOf = (entry) => {
+	const standard = entry.schema["~standard"];
+	const converter = isRecord(standard) ? standard["jsonSchema"] : void 0;
+	if (!isConverter(converter)) return;
+	try {
+		const converted = converter.input({ target: "draft-2020-12" });
+		return isRecord(converted) ? converted : void 0;
+	} catch {
+		return;
+	}
+};
+const kindOfValue = (value) => typeof value === "boolean" ? "boolean" : typeof value === "number" ? "number" : typeof value === "string" ? "text" : "json";
+const text = (value) => typeof value === "string" ? value : void 0;
+function fieldOf(key, entry) {
+	const schema = jsonSchemaOf(entry);
+	const values = schema?.["enum"];
+	const choices = isList(values) ? values.filter((value) => typeof value === "string" || typeof value === "number") : [];
+	const type = schema?.["type"];
+	return {
+		key,
+		kind: choices.length > 0 ? "choice" : type === "boolean" ? "boolean" : type === "number" || type === "integer" ? "number" : type === "string" ? "text" : type === void 0 ? kindOfValue(entry.default) : "json",
+		choices,
+		title: text(schema?.["title"]),
+		description: text(schema?.["description"]),
+		default: entry.default
+	};
+}
+/**
+* The form fields of one scope of a settings definition, in declaration order:
+* `settingFields(settings.schemas.organization)`.
+*/
+function settingFields(entries) {
+	const fields = [];
+	for (const key of Object.keys(entries)) {
+		const entry = entries[key];
+		if (!entry) continue;
+		fields.push(fieldOf(key, entry));
+	}
+	return fields;
+}
+function storeOf(options) {
+	const { user, organization } = options;
+	if (user) return {
+		get: () => user.getUser(),
+		set: (key, value) => user.setUser(key, value),
+		reset: (key) => user.resetUser(key)
+	};
+	if (!organization) throw new TypeError("better-supabase: createSettingsController needs `user` or `organization`");
+	const organizationId = options.organizationId ?? null;
+	if (organizationId === null) return;
+	return {
+		get: () => organization.getOrganization(organizationId),
+		set: (key, value) => organization.setOrganization(organizationId, key, value),
+		reset: (key) => organization.resetOrganization(organizationId, key)
+	};
+}
+/**
+* One scope of the app's settings for a settings page: the form fields
+* generated from the definition, the stored values over the defaults, and `set`
+* and `reset` per key.
+*/
+function createSettingsController(options) {
+	const store = storeOf(options);
+	return defineController({
+		fields: settingFields(options.entries),
+		values: void 0,
+		saving: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			if (!store) return;
+			const run = state.run();
+			const result = await store.get();
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				values: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const waiting = () => err(dbError("invalid_input", "No organization to save the setting for"));
+		const set = async (key, value) => {
+			if (!store) return waiting();
+			state.set({
+				saving: key,
+				error: void 0
+			});
+			const result = await store.set(key, value);
+			if (!result.ok) {
+				state.set({
+					saving: void 0,
+					error: result.error
+				});
+				return result;
+			}
+			state.set((current) => ({
+				saving: void 0,
+				...current.values === void 0 ? {} : { values: {
+					...current.values,
+					[key]: result.data
+				} }
+			}));
+			return result;
+		};
+		return {
+			actions: {
+				refresh,
+				set,
+				setField: (key, value) => set(key, value),
+				reset: async (key) => {
+					if (!store) return waiting();
+					state.set({
+						saving: key,
+						error: void 0
+					});
+					const result = await store.reset(key);
+					state.set(result.ok ? { saving: void 0 } : {
+						saving: void 0,
+						error: result.error
+					});
+					if (result.ok) await refresh();
+					return result;
+				}
+			},
+			start: () => store ? whileSignedIn(options.auth, () => {
+				refresh();
+			}) : void 0
+		};
+	});
+}
+//#endregion
+export { settingFields as n, createSettingsController as t };

package/dist/client-CnENAa0E.d.ts

@@ -0,0 +1,69 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+import { a as WorkflowRunStatus, g as Workflows, n as WorkflowRun } from "./workflows-D8U7KyXJ.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/workflows/client.d.ts
+interface WorkflowRunsControllerOptions {
+  readonly client: {
+    readonly runs: Pick<Workflows["runs"], "list">;
+  };
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /**
+   * The tenant whose runs to list; it also joins the tenant's
+   * `workflow-runs:<tenant>` topic. Without one, the signed-in user's own runs
+   * load once.
+   */
+  readonly tenant?: string | null;
+  readonly definition?: string;
+  readonly status?: WorkflowRunStatus;
+  readonly limit?: number;
+}
+interface WorkflowRunsSnapshot {
+  /** `undefined` until the first load. */
+  readonly runs: readonly WorkflowRun[] | undefined;
+  readonly error: DbError | undefined;
+  readonly status: SubscriptionStatus;
+}
+interface WorkflowRunsActions {
+  readonly refresh: () => Promise<void>;
+}
+type WorkflowRunsController = Controller<WorkflowRunsSnapshot, WorkflowRunsActions>;
+/**
+ * The runs the signed-in user may read, newest first, loaded again when a run
+ * in the tenant changes status.
+ */
+declare function createWorkflowRunsController(options: WorkflowRunsControllerOptions): WorkflowRunsController;
+interface WorkflowRunControllerOptions {
+  readonly client: {
+    readonly runs: Pick<Workflows["runs"], "get" | "requestCancel">;
+  };
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The run's id or its engine's id; `null` waits. */
+  readonly run: string | null;
+}
+interface WorkflowRunSnapshot {
+  /** `undefined` until the first load, and when the user may not read the run. */
+  readonly run: WorkflowRun | undefined;
+  readonly error: DbError | undefined;
+  readonly status: SubscriptionStatus;
+}
+interface WorkflowRunActions {
+  readonly refresh: () => Promise<void>;
+  /** Asks the engine to cancel the run, then loads it again. */
+  readonly cancel: () => Promise<void>;
+}
+type WorkflowRunController = Controller<WorkflowRunSnapshot, WorkflowRunActions>;
+/**
+ * One run by its id or its engine's id, loaded again on each status change
+ * broadcast on `workflow-run:<id>`.
+ */
+declare function createWorkflowRunController(options: WorkflowRunControllerOptions): WorkflowRunController;
+//#endregion
+export { WorkflowRunsActions as a, WorkflowRunsSnapshot as c, WorkflowRunSnapshot as i, createWorkflowRunController as l, WorkflowRunController as n, WorkflowRunsController as o, WorkflowRunControllerOptions as r, WorkflowRunsControllerOptions as s, WorkflowRunActions as t, createWorkflowRunsController as u };

package/dist/client-Cp79i2ZE.d.ts

@@ -0,0 +1,152 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, b as DbError, t as AsyncResult } from "./result-C6jDfedy.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, 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/reactions/reactions.d.ts
+interface ReactionsOptions extends BlockTemporalOptions, BlockTenantOptions {
+  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[];
+}
+/** A subject's votes. */
+interface VoteTally {
+  /** Up votes minus down votes. */
+  readonly score: number;
+  readonly up: number;
+  readonly down: number;
+  /** The signed-in user's vote: `1`, `-1`, or `0` for none. */
+  readonly vote: -1 | 0 | 1;
+}
+/** `1` votes up, `-1` down, `0` clears the vote. */
+type VoteValue = -1 | 0 | 1;
+interface VoteOptions {
+  /** The service role votes for this actor (default `service`). */
+  readonly actor?: 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;
+}
+/** Every method but `deleteCustomEmoji` acts in the block's `tenant`. */
+interface Reactions {
+  /** Adds or removes the caller's reaction; returns the subject's reactions. */
+  react(subject: SubjectRef, emoji: string, options?: ReactOptions): AsyncResult<readonly ReactionCount[]>;
+  /**
+   * The reactions of `subjects` (up to 200 of each type), keyed by
+   * `subjectKey(subject)` (`type:id`). Subjects without reactions may be left
+   * out.
+   */
+  summary(subjects: readonly SubjectRef[]): AsyncResult<Readonly<Record<string, readonly ReactionCount[]>>>;
+  /**
+   * Sets the caller's vote on `subject` and returns its tally. Votes use the
+   * `create` permission and the subject's read rules, like `react`.
+   */
+  vote(subject: SubjectRef, value: VoteValue, options?: VoteOptions): AsyncResult<VoteTally>;
+  /**
+   * The vote tallies of `subjects` (up to 200 of each type), keyed by
+   * `subjectKey(subject)`.
+   */
+  votes(subjects: readonly SubjectRef[]): AsyncResult<Readonly<Record<string, VoteTally>>>;
+  /** The tenant's custom emoji, by shortcode. */
+  customEmoji(): AsyncResult<readonly CustomEmoji[]>;
+  /** Adds a custom emoji, or replaces the image of an existing shortcode. */
+  saveCustomEmoji(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;
+  };
+  /**
+   * The tenant whose reaction broadcasts to hear, the client's own; the
+   * controller waits without one.
+   */
+  readonly tenant: string | null;
+  /**
+   * The subjects on screen, at most 200 of each type; `setSubjects` changes
+   * them.
+   */
+  readonly subjects: readonly SubjectRef[];
+  /**
+   * `blockConfig.reactions.options.topic` from `blocks.generated.ts`; `null`
+   * loads without listening.
+   */
+  readonly topic?: string | null;
+}
+interface ReactionsSnapshot {
+  /**
+   * Reactions keyed by `subjectKey(subject)` (`type: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: (subject: SubjectRef, 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: (subjects: readonly SubjectRef[]) => void;
+}
+type ReactionsController = Controller<ReactionsSnapshot, ReactionsActions>;
+/**
+ * The reactions of the subjects on screen, loaded again when anyone in the
+ * tenant 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, VoteOptions as f, reactionsTopic as g, createReactions as h, ReactionsSnapshot as i, ReactionCount as l, VoteValue as m, ReactionsController as n, CustomEmoji as o, VoteTally as p, ReactionsControllerOptions as r, CustomEmojiInput as s, ReactionsActions as t, Reactions as u };