better-supabase 0.5.0 → 0.6.0

package/dist/blocks/ai-tasks/index.js

@@ -0,0 +1,203 @@
+import { t as DbException } from "../../db-exception-CnWcYPxL.js";
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { s as nowInstant } from "../../temporal-BJGitm-h.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { n as nextCronRun, t as assertCron } from "../../cron-DVPUg5k3.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { O as textOf, c as errorText, d as isRecord, h as optionalText, i as blockCall, k as toInstant, l as injectableOf, m as optionalInstant, n as applyTemporal, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { n as runStateOf } from "../../run-state-CgBKzYMW.js";
+//#region src/blocks/ai-tasks/ai-tasks.ts
+const STATUSES = [
+	"queued",
+	"running",
+	"completed",
+	"failed"
+];
+const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
+function runOf(value) {
+	const row = recordOf(value, "ai_task_runs");
+	return {
+		id: textOf(row["id"]),
+		taskId: textOf(row["task_id"]),
+		organizationId: textOf(row["organization_id"]),
+		userId: textOf(row["user_id"]),
+		status: runStateOf(row["status"], STATUSES, "failed"),
+		scheduledFor: instant(row["scheduled_for"]),
+		chatId: optionalText(row["chat_id"]),
+		error: optionalText(row["error"]),
+		startedAt: optionalInstant(row["started_at"]),
+		finishedAt: optionalInstant(row["finished_at"]),
+		createdAt: instant(row["created_at"])
+	};
+}
+function taskOf(value) {
+	const row = recordOf(value, "ai_scheduled_tasks");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		userId: textOf(row["user_id"]),
+		chatId: optionalText(row["chat_id"]),
+		agentId: optionalText(row["agent_id"]),
+		title: textOf(row["title"]),
+		prompt: textOf(row["prompt"]),
+		cron: textOf(row["cron"]),
+		timezone: textOf(row["timezone"]),
+		enabled: row["enabled"] !== false,
+		nextRunAt: optionalInstant(row["next_run_at"]),
+		lastRunAt: optionalInstant(row["last_run_at"]),
+		lastRun: isRecord(row["last_run"]) ? runOf(row["last_run"]) : void 0,
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(row["updated_at"])
+	};
+}
+const invalid = (message) => dbError("invalid_input", message, { hint: "AI_TASK_INVALID" });
+function fieldsArg(fields) {
+	const out = {};
+	if (fields.title !== void 0) out["title"] = fields.title;
+	if (fields.prompt !== void 0) out["prompt"] = fields.prompt;
+	if (fields.cron !== void 0) out["cron"] = fields.cron;
+	if (fields.timezone !== void 0) out["timezone"] = fields.timezone;
+	if (fields.chatId !== void 0) out["chat_id"] = fields.chatId;
+	if (fields.agentId !== void 0) out["agent_id"] = fields.agentId;
+	return out;
+}
+/** Prompts users schedule on a cron, and the scheduler that runs them. */
+function createAiTasks(options) {
+	applyTemporal(options);
+	injectableOf("ai-tasks runner", options.run);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const now = options.now ?? nowInstant;
+	/** The next occurrence, or an `invalid_input` error for a bad cron or zone. */
+	const next = (cron, timezone) => {
+		try {
+			assertCron(cron);
+			return ok(nextCronRun(cron, timezone, now()));
+		} catch (cause) {
+			return err(invalid(errorText(cause)));
+		}
+	};
+	const save = (organizationId, taskId, fields, nextRunAt) => {
+		const args = fieldsArg(fields);
+		if (fields.enabled !== void 0) args["enabled"] = fields.enabled;
+		return call("save_ai_task", {
+			tenant: organizationId,
+			id: taskId,
+			fields: args,
+			next_run_at: nextRunAt?.toString()
+		}, taskOf).andThen((task) => scheduleNow(task));
+	};
+	const scheduleNow = (task) => {
+		if (options.service === void 0 || !task.enabled || task.nextRunAt !== void 0) return AsyncResult.ok(task);
+		const upcoming = next(task.cron, task.timezone);
+		if (!upcoming.ok) return AsyncResult.ok(task);
+		return service("schedule_ai_tasks", { items: { items: [{
+			id: task.id,
+			next_run_at: upcoming.data.toString()
+		}] } }, (count) => count === 1 ? {
+			...task,
+			nextRunAt: upcoming.data
+		} : task);
+	};
+	const schedule = (fields, fallbackZone) => {
+		if (fields.cron === void 0 && fields.timezone === void 0) return AsyncResult.ok(void 0);
+		if (fields.cron === void 0) return AsyncResult.err(invalid("change cron together with timezone"));
+		const result = next(fields.cron, fields.timezone ?? fallbackZone ?? "UTC");
+		return result.ok ? AsyncResult.ok(result.data) : AsyncResult.err(result.error);
+	};
+	const tick = (tickOptions = {}) => service("claim_due_ai_tasks", { batch: tickOptions.batch }, (value) => recordOf(value, "claim_due_ai_tasks")).andThen((claimed) => {
+		const runs = recordsOf(claimed["runs"], "claim_due_ai_tasks").map(runOf);
+		const items = recordsOf(claimed["unscheduled"], "claim_due_ai_tasks").map((row) => {
+			const result = next(textOf(row["cron"]), textOf(row["timezone"]));
+			return {
+				id: textOf(row["id"]),
+				next_run_at: (result.ok ? result.data : now().add({ hours: 24 })).toString()
+			};
+		});
+		return items.length === 0 ? AsyncResult.ok(runs) : service("schedule_ai_tasks", { items: { items } }, () => runs);
+	});
+	const execute = (runId, executeOptions = {}) => service("start_ai_task_run", { id: runId }, (value) => value).andThen((value) => AsyncResult.from(async () => {
+		if (!isRecord(value)) return ok(false);
+		const run = runOf(value);
+		const task = taskOf(value["task"]);
+		const runner = options.run;
+		let outcome;
+		if (runner === void 0) outcome = {
+			task,
+			run,
+			ok: false,
+			error: "createAiTasks has no run"
+		};
+		else try {
+			const result = await runner(task, run, executeOptions.signal ?? new AbortController().signal);
+			outcome = result?.chatId === void 0 ? {
+				task,
+				run,
+				ok: true
+			} : {
+				task,
+				run,
+				ok: true,
+				chatId: result.chatId
+			};
+		} catch (cause) {
+			outcome = {
+				task,
+				run,
+				ok: false,
+				error: errorText(cause)
+			};
+		}
+		const finished = await service("finish_ai_task_run", {
+			id: run.id,
+			succeeded: outcome.ok,
+			error: outcome.error,
+			chat_id: outcome.chatId
+		}, (done) => done === true);
+		if (!finished.ok) return finished;
+		await options.notify?.(outcome);
+		return ok(true);
+	}));
+	return {
+		create: (organizationId, task) => schedule(task, task.timezone).andThen((nextRunAt) => save(organizationId, void 0, task, nextRunAt)),
+		update: (organizationId, taskId, fields) => schedule(fields, fields.timezone).andThen((nextRunAt) => save(organizationId, taskId, fields, nextRunAt)),
+		pause: (organizationId, taskId) => save(organizationId, taskId, { enabled: false }, void 0),
+		resume: (organizationId, taskId) => save(organizationId, taskId, { enabled: true }, void 0),
+		remove: (taskId) => call("delete_ai_task", { id: taskId }, (value) => value === true),
+		list: (organizationId, listOptions = {}) => call("list_ai_tasks", {
+			tenant: organizationId,
+			mine: listOptions.all !== true
+		}, (value) => recordsOf(value, "list_ai_tasks").map(taskOf)),
+		runs: (taskId, runsOptions = {}) => call("list_ai_task_runs", {
+			task_id: taskId,
+			max_rows: runsOptions.limit
+		}, (value) => recordsOf(value, "list_ai_task_runs").map(runOf)),
+		tick,
+		execute,
+		runJob: () => async (payload, _job, signal) => {
+			const result = await execute(payload.run_id, { signal });
+			if (!result.ok) throw new DbException(result.error);
+		},
+		drain: (drainOptions = {}) => tick(drainOptions).andThen((runs) => AsyncResult.from(async () => {
+			let done = 0;
+			const failures = [];
+			for (const run of runs) {
+				if (drainOptions.signal?.aborted) break;
+				const result = await execute(run.id, drainOptions);
+				if (!result.ok) failures.push({
+					runId: run.id,
+					error: result.error
+				});
+				else if (result.data) done += 1;
+			}
+			const [first] = failures;
+			if (first === void 0) return ok(done);
+			return err({
+				...first.error,
+				details: `${failures.length} of ${runs.length} runs failed: ${failures.map((failure) => `${failure.runId} (${failure.error.message})`).join(", ")}`
+			});
+		}))
+	};
+}
+//#endregion
+export { createAiTasks, rpcTransport, sqlTransport };

package/dist/blocks/announcements/index.d.ts

@@ -0,0 +1,3 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { a as Announcements, c as createAnnouncements, i as AnnouncementSeverity, n as AnnouncementAudience, o as AnnouncementsOptions, r as AnnouncementInput, s as ManagedAnnouncement, t as Announcement } from "../../announcements-ZRGnScWI.js";
+export { type Announcement, type AnnouncementAudience, type AnnouncementInput, type AnnouncementSeverity, type Announcements, type AnnouncementsOptions, type BlockTransport, type ManagedAnnouncement, createAnnouncements, rpcTransport, sqlTransport };

package/dist/blocks/announcements/index.js

@@ -0,0 +1,3 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { t as createAnnouncements } from "../../announcements-CiyOs-xP.js";
+export { createAnnouncements, rpcTransport, sqlTransport };

package/dist/blocks/announcements/react/index.d.ts

@@ -0,0 +1,31 @@
+import { b as DbError } from "../../../result-D7y2fT87.js";
+import { x as SubscriptionStatus } from "../../../index-DunNRdnT.js";
+import { t as Announcement } from "../../../announcements-ZRGnScWI.js";
+//#region src/blocks/announcements/react/index.d.ts
+export interface UseAnnouncementsOptions {
+  /** The active tenant, for tenant, role and plan audiences. */
+  readonly organizationId?: string | null;
+  /** The topic the module broadcasts to (`sql.modules.announcements.options.topic`); `null` loads once. */
+  readonly topic?: string | null;
+  /** The schema the calls go to: the module schema (default `better_supabase`), or the API schema from `sql.modules.<module>.api`. */
+  readonly schema?: string;
+}
+export interface AnnouncementsState {
+  /** `undefined` until the first load. */
+  readonly items: readonly Announcement[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+  /** Hides one for the user, then drops it from `items`. */
+  readonly dismiss: (announcementId: string) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+/**
+ * The signed-in user's live announcements, loaded again whenever staff
+ * publish, change or remove one.
+ *
+ * ```tsx
+ * const { items, dismiss } = useAnnouncements({ organizationId });
+ * ```
+ */
+export declare function useAnnouncements(options?: UseAnnouncementsOptions): AnnouncementsState;
+//#endregion

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

@@ -0,0 +1,86 @@
+"use client";
+import { i as useAuth, l as useSupabase } from "../../../hooks-1BTCJsiw.js";
+import { n as rpcTransport } from "../../../block-transport-BLr-ZgLc.js";
+import { t as watchTopic } from "../../../react-topic-seAWjL3_.js";
+import { t as createAnnouncements } from "../../../announcements-CiyOs-xP.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+//#region src/blocks/announcements/react/index.ts
+/**
+* The signed-in user's live announcements, loaded again whenever staff
+* publish, change or remove one.
+*
+* ```tsx
+* const { items, dismiss } = useAnnouncements({ organizationId });
+* ```
+*/
+function useAnnouncements(options = {}) {
+	const supabase = useSupabase();
+	const auth = useAuth();
+	const [items, setItems] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	const [status, setStatus] = useState("closed");
+	const organizationId = options.organizationId ?? null;
+	const topic = options.topic === void 0 ? "announcements" : options.topic;
+	const schema = options.schema;
+	const client = useMemo(() => createAnnouncements({
+		transport: rpcTransport(supabase),
+		...schema === void 0 ? {} : { schema }
+	}), [supabase, schema]);
+	const userId = auth.user?.id ?? null;
+	const signedIn = auth.status === "signed-in";
+	const apply = useCallback((result) => {
+		if (result.ok) {
+			setItems(result.data);
+			setError(void 0);
+		} else setError(result.error);
+	}, []);
+	const refresh = useCallback(async () => {
+		apply(await client.listActive(organizationId));
+	}, [
+		client,
+		organizationId,
+		apply
+	]);
+	const dismiss = useCallback(async (announcementId) => {
+		const result = await client.dismiss(announcementId);
+		if (!result.ok) {
+			setError(result.error);
+			return;
+		}
+		setItems((current) => current?.filter((item) => item.id !== announcementId));
+	}, [client]);
+	useEffect(() => {
+		if (!signedIn) return;
+		let active = true;
+		const load = () => void client.listActive(organizationId).then((result) => {
+			if (active) apply(result);
+		});
+		load();
+		const leave = topic ? watchTopic(supabase, topic, {
+			onMessage: load,
+			onRejoin: load,
+			onStatus: setStatus
+		}) : void 0;
+		return () => {
+			active = false;
+			leave?.();
+		};
+	}, [
+		client,
+		supabase,
+		topic,
+		organizationId,
+		signedIn,
+		userId,
+		apply
+	]);
+	return {
+		items,
+		status,
+		error,
+		dismiss,
+		refresh
+	};
+}
+//#endregion
+export { useAnnouncements };

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

@@ -0,0 +1,6 @@
+import { AnnouncementsState, UseAnnouncementsOptions } from "./index.js";
+//#region src/blocks/announcements/react/server.d.ts
+/** The `react-server` build of `useAnnouncements`: call `announcements.listActive()` instead. */
+export declare const useAnnouncements: (options?: UseAnnouncementsOptions) => AnnouncementsState;
+//#endregion
+export type { AnnouncementsState, UseAnnouncementsOptions };

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

@@ -0,0 +1,7 @@
+//#region src/blocks/announcements/react/server.ts
+/** The `react-server` build of `useAnnouncements`: call `announcements.listActive()` instead. */
+const useAnnouncements = () => {
+	throw new Error("better-supabase: useAnnouncements() runs in Client Components only. In Server Components call `announcements.listActive()` instead.");
+};
+//#endregion
+export { useAnnouncements };

package/dist/blocks/api-keys/index.d.ts

@@ -0,0 +1,35 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { r as AuthState } from "../../resolve-KW8nCeL6.js";
+import { t as BlockProblemOptions } from "../../problem-DD8LZFjc.js";
+import { a as ApiKeyResolverOptions, c as ApiKeysOptions, d as ParsedApiKey, f as apiKeyChecksum, g as parseApiKey, h as createApiKeys, i as ApiKeyExtraClaim, l as CreateApiKeyInput, m as apiKeyResolver, n as ApiKeyCheck, o as ApiKeyState, p as apiKeyClaims, r as ApiKeyClaimsOptions, s as ApiKeys, t as ApiKey, u as CreatedApiKey } from "../../api-keys-rCGtKaZA.js";
+import { Entry } from "@supabase/middleware";
+import { AuthMode, JWTClaims, UserClaims } from "@supabase/server";
+//#region src/blocks/api-keys/pipeline.d.ts
+interface WithApiKeyOptions extends ApiKeyResolverOptions, BlockProblemOptions {}
+/** The API key a request verified with, as `withApiKey` puts it on `ctx.auth`. */
+type ApiKeyAuth = Extract<AuthState, {
+  readonly kind: "apiKey";
+}>;
+/** The keys `withApiKey` puts on `ctx`. */
+interface ApiKeyContributions {
+  readonly auth: ApiKeyAuth;
+  /** The key's claims (`sub`, `role: authenticated`, `api_key`), for `withPostgresClient`. */
+  readonly jwtClaims: JWTClaims | null;
+  readonly userClaims: UserClaims | null;
+  readonly authMode: AuthMode;
+}
+/**
+ * A `@supabase/server` pipeline entry for routes that take API keys
+ * (`x-api-key`, or `Authorization: Bearer` with a key): it verifies the key
+ * with `keys.verify`, answers a missing, invalid or rate-limited key with
+ * Problem Details, and contributes `ctx.auth` and the `withSupabase` keys
+ * (`jwtClaims`, `userClaims`, `authMode`) from the key's claims, so
+ * `withPostgresClient` and `withBetterPostgres` run queries as the key.
+ *
+ * ```ts
+ * pipeline([withApiKey({ keys }), withPostgresClient(), withBetterPostgres(betterSupabase)()], (req, ctx) => ...)
+ * ```
+ */
+export declare function withApiKey(options: WithApiKeyOptions): Entry<ApiKeyContributions>;
+//#endregion
+export { type ApiKey, type ApiKeyAuth, type ApiKeyCheck, type ApiKeyClaimsOptions, type ApiKeyContributions, type ApiKeyExtraClaim, type ApiKeyResolverOptions, type ApiKeyState, type ApiKeys, type ApiKeysOptions, type BlockTransport, type CreateApiKeyInput, type CreatedApiKey, type ParsedApiKey, type WithApiKeyOptions, apiKeyChecksum, apiKeyClaims, apiKeyResolver, createApiKeys, parseApiKey, rpcTransport, sqlTransport };