better-supabase 0.5.0 → 0.6.0

package/dist/blocks/inbox/react/index.js

@@ -0,0 +1,225 @@
+"use client";
+import { i as refreshRealtimeAuth } from "../../../live-CTAZQkwl.js";
+import { i as useAuth, l as useSupabase } from "../../../hooks-1BTCJsiw.js";
+import { t as watchTopic } from "../../../react-topic-seAWjL3_.js";
+import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/blocks/inbox/react/index.ts
+function useLoader(load) {
+	const [items, setItems] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	const latest = useRef(load);
+	latest.current = load;
+	return {
+		items,
+		setItems,
+		error,
+		refresh: useCallback(async () => {
+			try {
+				setItems(await latest.current());
+				setError(void 0);
+			} catch (cause) {
+				setError(cause);
+			}
+		}, [])
+	};
+}
+/**
+* The staff view of an organization's conversations, kept current: loads,
+* then loads again after each ping on `inbox:org:<id>` and on rejoin.
+*/
+function useInbox(options) {
+	const supabase = useSupabase();
+	const auth = useAuth();
+	const { items, error, refresh } = useLoader(options.load);
+	const [status, setStatus] = useState("closed");
+	const onMessage = useRef(options.onMessage);
+	onMessage.current = options.onMessage;
+	const topic = options.organizationId === null ? null : `${options.topic ?? "inbox"}:org:${options.organizationId}`;
+	useEffect(() => {
+		if (auth.status !== "signed-in" || topic === null) return;
+		refresh();
+		return watchTopic(supabase, topic, {
+			onMessage: (event, payload) => {
+				onMessage.current?.(event, payload);
+				refresh();
+			},
+			onRejoin: () => void refresh(),
+			onStatus: setStatus
+		});
+	}, [
+		supabase,
+		topic,
+		auth.status,
+		refresh
+	]);
+	return {
+		items,
+		status,
+		error,
+		refresh
+	};
+}
+/** Joins `topic` for messages and typing pings; returns the function that leaves it. */
+function joinConversation(supabase, topic, handlers) {
+	const { userId, typingMs, refresh, setStatus, setTypers } = handlers;
+	let closed = false;
+	let joined = false;
+	const seen = /* @__PURE__ */ new Map();
+	const typer = (who, on) => {
+		const timer = seen.get(who);
+		if (timer !== void 0) clearTimeout(timer);
+		if (on) seen.set(who, setTimeout(() => {
+			typer(who, false);
+		}, typingMs));
+		else seen.delete(who);
+		setTypers([...seen.keys()]);
+	};
+	const joinedChannel = supabase.channel(topic, { config: {
+		private: true,
+		broadcast: { self: false }
+	} });
+	handlers.channel.current = joinedChannel;
+	joinedChannel.on("broadcast", { event: "*" }, (message) => {
+		const payload = message["payload"];
+		if (message.event === "typing") {
+			if (typeof payload !== "object" || payload === null) return;
+			const who = "user_id" in payload ? String(payload.user_id) : "";
+			if (who !== "" && who !== userId) typer(who, !("typing" in payload) || payload.typing !== false);
+			return;
+		}
+		refresh();
+	});
+	(async () => {
+		setStatus("joining");
+		await refreshRealtimeAuth(supabase);
+		if (closed) return;
+		joinedChannel.subscribe((state) => {
+			switch (state) {
+				case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
+					if (joined) refresh();
+					joined = true;
+					setStatus("subscribed");
+					return;
+				case REALTIME_SUBSCRIBE_STATES.CLOSED:
+					setStatus("closed");
+					return;
+				case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
+				case REALTIME_SUBSCRIBE_STATES.TIMED_OUT:
+					setStatus("error");
+					return;
+				default: throw new Error(`Unknown realtime status ${String(state)}`);
+			}
+		});
+	})();
+	return () => {
+		closed = true;
+		for (const timer of seen.values()) clearTimeout(timer);
+		handlers.channel.current = null;
+		setTypers([]);
+		supabase.removeChannel(joinedChannel);
+		setStatus("closed");
+	};
+}
+/**
+* One conversation's messages, kept current over `inbox:<id>`, with typing
+* pings between staff and the contact. Notes never reach this topic.
+*/
+function useConversation(options) {
+	const supabase = useSupabase();
+	const auth = useAuth();
+	const { items, error, refresh } = useLoader(options.load);
+	const [status, setStatus] = useState("closed");
+	const [typing, setTypers] = useState([]);
+	const channel = useRef(null);
+	const userId = auth.user?.id ?? null;
+	const typingMs = options.typingMs ?? 5e3;
+	const topic = options.conversationId === null ? null : `${options.topic ?? "inbox"}:${options.conversationId}`;
+	useEffect(() => {
+		if (auth.status !== "signed-in" || topic === null) return;
+		refresh();
+		return joinConversation(supabase, topic, {
+			userId,
+			typingMs,
+			refresh,
+			setStatus,
+			setTypers,
+			channel
+		});
+	}, [
+		supabase,
+		topic,
+		auth.status,
+		userId,
+		typingMs,
+		refresh
+	]);
+	return {
+		items,
+		status,
+		error,
+		refresh,
+		typing,
+		setTyping: useCallback((on) => {
+			if (userId === null) return;
+			channel.current?.send({
+				type: "broadcast",
+				event: "typing",
+				payload: {
+					user_id: userId,
+					typing: on
+				}
+			});
+		}, [userId])
+	};
+}
+function storage() {
+	try {
+		return typeof localStorage === "undefined" ? void 0 : localStorage;
+	} catch {
+		return;
+	}
+}
+/**
+* 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.
+*/
+function useInboxWidget(options) {
+	const key = options.storageKey === void 0 ? "better-supabase:inbox-widget" : options.storageKey;
+	const [conversationId, setConversationId] = useState(() => key === null ? null : storage()?.getItem(key) ?? null);
+	const latest = useRef(options);
+	latest.current = options;
+	const conversation = useConversation({
+		conversationId,
+		load: () => conversationId === null ? Promise.resolve([]) : latest.current.load(conversationId),
+		...options.topic === void 0 ? {} : { topic: options.topic }
+	});
+	const { refresh } = conversation;
+	const submit = useCallback(async (message) => {
+		if (conversationId === null) {
+			const id = await latest.current.open(message);
+			if (key !== null) storage()?.setItem(key, id);
+			setConversationId(id);
+			return;
+		}
+		await latest.current.send(conversationId, message);
+		await refresh();
+	}, [
+		conversationId,
+		key,
+		refresh
+	]);
+	const reset = useCallback(() => {
+		if (key !== null) storage()?.removeItem(key);
+		setConversationId(null);
+	}, [key]);
+	return {
+		...conversation,
+		conversationId,
+		submit,
+		reset
+	};
+}
+//#endregion
+export { useConversation, useInbox, useInboxWidget };

package/dist/blocks/inbox/react/server.d.ts

@@ -0,0 +1,10 @@
+import { a as UseConversationOptions, i as InboxWidgetState, n as InboxListState, o as UseInboxOptions, r as InboxSource, s as UseInboxWidgetOptions, t as ConversationState } from "../../../index-ACiNPN4Z.js";
+//#region src/blocks/inbox/react/server.d.ts
+/** The `react-server` build of `useInbox`: call `inbox.conversations.list()` instead. */
+export declare const useInbox: <T>(options: UseInboxOptions<T>) => InboxListState<T>;
+/** The `react-server` build of `useConversation`: call `inbox.messages.list()` instead. */
+export declare const useConversation: <T>(options: UseConversationOptions<T>) => ConversationState<T>;
+/** The `react-server` build of `useInboxWidget`. */
+export declare const useInboxWidget: <T>(options: UseInboxWidgetOptions<T>) => InboxWidgetState<T>;
+//#endregion
+export type { ConversationState, InboxListState, InboxSource, InboxWidgetState, UseConversationOptions, UseInboxOptions, UseInboxWidgetOptions };

package/dist/blocks/inbox/react/server.js

@@ -0,0 +1,12 @@
+//#region src/blocks/inbox/react/server.ts
+const clientOnly = (hook, instead) => {
+	throw new Error(`better-supabase: ${hook}() runs in Client Components only. In Server Components call ${instead} instead.`);
+};
+/** The `react-server` build of `useInbox`: call `inbox.conversations.list()` instead. */
+const useInbox = () => clientOnly("useInbox", "`inbox.conversations.list()`");
+/** The `react-server` build of `useConversation`: call `inbox.messages.list()` instead. */
+const useConversation = () => clientOnly("useConversation", "`inbox.messages.list()`");
+/** The `react-server` build of `useInboxWidget`. */
+const useInboxWidget = () => clientOnly("useInboxWidget", "`inbox.messages.list()`");
+//#endregion
+export { useConversation, useInbox, useInboxWidget };

package/dist/blocks/index.d.ts

@@ -0,0 +1,65 @@
+import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as BlockTransport } from "../block-transport-DvaoPuZ9.js";
+import { a as EventHub } from "../events-DWDhx77e.js";
+import { r as CredentialProvider } from "../provider-BH5UWZJ6.js";
+import { i as CursorPageOptions, n as BlockOptions } from "../block-helpers-CKtbFcRv.js";
+import { f as AiFiles } from "../types-C05bxW-W.js";
+import { n as FinalRunState, r as RunState, t as FINAL_RUN_STATES } from "../run-state-CPo-1X2B.js";
+import { r as EventSink } from "../cloud-event-C1JCc1bH.js";
+import { r as AiTaskOutcome } from "../ai-tasks-Cd1HMFvB.js";
+import { a as BlockTransportMiddleware, c as ExtendBlockTools, d as extendBlock, f as withBlockHooks, i as BlockMethodName, l as WithBlockHooksOptions, n as BlockHooks, o as BlockTransportRequest, p as wrapTransport, r as BlockMethodHooks, s as ExtendBlockOptions, t as BlockHookInfo, u as defineTransportMiddleware } from "../block-hooks-plbZ0AbJ.js";
+import { n as FieldsOf, r as blockFields, t as BlockFields } from "../block-fields-SJ6fEf3o.js";
+//#region src/blocks/create-blocks.d.ts
+/** The CloudEvents `source` of block events that `createBlocks` forwards. */
+export declare const BLOCK_EVENT_SOURCE = "/better-supabase/blocks";
+interface CreateBlocksOptions extends BlockOptions {
+  /** Connectors, ai-providers and the builder store their secrets here. */
+  readonly credentials?: CredentialProvider;
+  /** `betterSupabase.events`, for the block events of the blocks that emit them. */
+  readonly events?: EventHub;
+  /**
+   * Where block events go, such as `auditLog.sink()`. Needs `events`; the
+   * forwarding lasts until `close()`, so build these blocks once rather than
+   * per request.
+   */
+  readonly audit?: EventSink;
+  /**
+   * The notification type ai-tasks sends for each finished run, through the
+   * `notifications` block. Its data is `{ taskId, runId, ok, error?, chatId? }`.
+   */
+  readonly aiTaskNotification?: string;
+}
+/** What each block factory receives: the shared options and its siblings. */
+interface BlockContext extends BlockOptions {
+  readonly credentials?: CredentialProvider;
+  readonly events?: EventHub;
+  /** The `aiFiles` block, for knowledge. */
+  readonly files?: AiFiles;
+  /** Sends `aiTaskNotification` through the `notifications` block, for ai-tasks. */
+  readonly notify?: (outcome: AiTaskOutcome) => unknown;
+}
+/** Builds one block, usually a block creator such as `createOrganizations`. */
+type BlockFactory<T = unknown> = (context: BlockContext) => T;
+type BlockFactories = Readonly<Record<string, BlockFactory>> & {
+  readonly aiFiles?: BlockFactory<AiFiles>;
+};
+type BuiltBlocks<F extends BlockFactories> = { readonly [K in keyof F]: F[K] extends BlockFactory<infer T> ? T : never; };
+/** `withBlockHooks` hooks for each block, keyed by the names in `factories`. */
+type BlocksHooks<F extends BlockFactories> = { readonly [K in keyof F]?: BlockHooks<BuiltBlocks<F>[K]>; };
+type Blocks<F extends BlockFactories> = BuiltBlocks<F> & {
+  /** Stops forwarding block events to `audit`. */
+  close(): void;
+};
+/**
+ * Builds the blocks in `factories` with one set of options, and wires the
+ * siblings they share: the `aiFiles` block into knowledge, `credentials`
+ * into connectors, ai-providers and the builder, the `notifications` block
+ * into ai-tasks (with `aiTaskNotification`), and block events into `audit`.
+ * Only the blocks you pass are imported, so the rest stay out of the bundle.
+ * `hooks` wraps each block's methods with `withBlockHooks`, so siblings that
+ * call a block (ai-tasks sending notifications) go through its hooks too.
+ */
+export declare function createBlocks<const F extends BlockFactories>(options: CreateBlocksOptions & {
+  readonly hooks?: NoInfer<BlocksHooks<F>>;
+}, factories: F): Blocks<F>;
+//#endregion
+export { type BlockContext, type BlockFactories, type BlockFactory, type BlockFields, type BlockHookInfo, type BlockHooks, type BlockMethodHooks, type BlockMethodName, type BlockOptions, type BlockTransport, type BlockTransportMiddleware, type BlockTransportRequest, type Blocks, type BlocksHooks, type CreateBlocksOptions, type CursorPageOptions, type ExtendBlockOptions, type ExtendBlockTools, FINAL_RUN_STATES, type FieldsOf, type FinalRunState, type RpcClient, type RunState, type WithBlockHooksOptions, blockFields, defineTransportMiddleware, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/index.js

@@ -0,0 +1,77 @@
+import { n as forwardBlockEvents } from "../cloud-event-BnmD5fb9.js";
+import { n as rpcTransport, r as sqlTransport } from "../block-transport-BLr-ZgLc.js";
+import { d as isRecord } from "../block-helpers-DWHxHsEQ.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks, t as defineTransportMiddleware } from "../block-hooks-BmjMyXTa.js";
+import { t as FINAL_RUN_STATES } from "../run-state-CgBKzYMW.js";
+import { t as blockFields } from "../block-fields-GFkxl4dP.js";
+//#region src/blocks/create-blocks.ts
+/** The CloudEvents `source` of block events that `createBlocks` forwards. */
+const BLOCK_EVENT_SOURCE = "/better-supabase/blocks";
+const isNotificationSender = (value) => isRecord(value) && typeof value["send"] === "function";
+/**
+* Builds the blocks in `factories` with one set of options, and wires the
+* siblings they share: the `aiFiles` block into knowledge, `credentials`
+* into connectors, ai-providers and the builder, the `notifications` block
+* into ai-tasks (with `aiTaskNotification`), and block events into `audit`.
+* Only the blocks you pass are imported, so the rest stay out of the bundle.
+* `hooks` wraps each block's methods with `withBlockHooks`, so siblings that
+* call a block (ai-tasks sending notifications) go through its hooks too.
+*/
+function createBlocks(options, factories) {
+	const { credentials, events, audit, aiTaskNotification, hooks, ...shared } = options;
+	if (audit !== void 0 && events === void 0) throw new TypeError("createBlocks: `audit` needs `events` to forward");
+	const built = /* @__PURE__ */ new Map();
+	const building = /* @__PURE__ */ new Set();
+	const notify = aiTaskNotification === void 0 || factories["notifications"] === void 0 ? void 0 : (outcome) => {
+		const notifications = build("notifications");
+		if (!isNotificationSender(notifications)) throw new TypeError("The notifications block has no send method");
+		return notifications.send(aiTaskNotification, {
+			recipients: [outcome.task.userId],
+			tenant: outcome.task.organizationId,
+			key: `ai-task-run:${outcome.run.id}`,
+			data: {
+				taskId: outcome.task.id,
+				runId: outcome.run.id,
+				ok: outcome.ok,
+				...outcome.error === void 0 ? {} : { error: outcome.error },
+				...outcome.chatId === void 0 ? {} : { chatId: outcome.chatId }
+			}
+		});
+	};
+	function contextFor(name) {
+		const files = name === "aiFiles" || factories.aiFiles === void 0 ? void 0 : build("aiFiles");
+		return {
+			...shared,
+			...credentials === void 0 ? {} : { credentials },
+			...events === void 0 ? {} : { events },
+			...files === void 0 ? {} : { files },
+			...notify === void 0 ? {} : { notify }
+		};
+	}
+	function build(name) {
+		if (built.has(name)) return built.get(name);
+		const factory = factories[name];
+		if (factory === void 0) throw new TypeError(`No block named "${name}"`);
+		if (building.has(name)) throw new TypeError(`The "${name}" block depends on itself`);
+		building.add(name);
+		try {
+			const created = factory(contextFor(name));
+			const blockHooks = hooks?.[name];
+			const block = blockHooks !== void 0 && isRecord(created) ? withBlockHooks(created, blockHooks, {
+				block: name,
+				...events === void 0 ? {} : { logger: events.logger }
+			}) : created;
+			built.set(name, block);
+			return block;
+		} finally {
+			building.delete(name);
+		}
+	}
+	const blocks = {};
+	for (const name of Object.keys(factories)) blocks[name] = build(name);
+	const stop = audit === void 0 || events === void 0 ? void 0 : forwardBlockEvents({ events }, audit, { source: BLOCK_EVENT_SOURCE });
+	blocks["close"] = () => stop?.();
+	return blocks;
+}
+//#endregion
+export { BLOCK_EVENT_SOURCE, FINAL_RUN_STATES, blockFields, createBlocks, defineTransportMiddleware, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };