better-supabase 0.5.1 → 0.6.0

package/dist/blocks/organizations/index.js

@@ -0,0 +1,400 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { t as temporal } from "../../temporal-required-BVvW7SYJ.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { i as emitBlockEvent } from "../../block-events-CrT8r7Fe.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { d as isRecord, i as blockCall, n as applyTemporal, x as recordsOf } from "../../block-helpers-DWHxHsEQ.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BmjMyXTa.js";
+import { t as blockFields } from "../../block-fields-GFkxl4dP.js";
+//#region src/blocks/organizations/organizations.ts
+const text = (value) => typeof value === "string" ? value : String(value);
+const optionalText = (value) => value === null || value === void 0 ? null : text(value);
+const extraOf = (row, known) => Object.fromEntries(Object.entries(row).filter(([key]) => !known.has(key)));
+const INVITATION_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"tenant",
+	"email",
+	"role",
+	"expires_at",
+	"created_at",
+	"invited_by",
+	"organization",
+	"prefill",
+	"inviter",
+	"token"
+]);
+function invitationFrom(row) {
+	const invitedBy = optionalText(row["invited_by"]);
+	const createdAt = optionalText(row["created_at"]);
+	return {
+		id: text(row["id"]),
+		organizationId: optionalText(row["tenant"]),
+		email: text(row["email"]),
+		role: text(row["role"]),
+		expiresAt: temporal().Instant.from(text(row["expires_at"])),
+		...createdAt === null ? {} : { createdAt: temporal().Instant.from(createdAt) },
+		...invitedBy === null ? {} : { invitedBy },
+		organization: isRecord(row["organization"]) ? row["organization"] : null,
+		prefill: isRecord(row["prefill"]) ? row["prefill"] : {},
+		inviter: isRecord(row["inviter"]) ? row["inviter"] : null,
+		extra: extraOf(row, INVITATION_KEYS)
+	};
+}
+const STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"accepted",
+	"declined",
+	"revoked",
+	"expired"
+]);
+function isStatus(value) {
+	return typeof value === "string" && STATUSES.has(value);
+}
+const PREVIEW_KEYS = /* @__PURE__ */ new Set([
+	"status",
+	"email",
+	"role",
+	"tenant",
+	"expires_at",
+	"organization",
+	"prefill"
+]);
+function previewFrom(row) {
+	const status = row["status"];
+	if (!isStatus(status)) throw new TypeError(`Unknown invitation status ${String(status)}`);
+	return {
+		status,
+		email: text(row["email"]),
+		role: text(row["role"]),
+		organizationId: optionalText(row["tenant"]),
+		expiresAt: temporal().Instant.from(text(row["expires_at"])),
+		organization: isRecord(row["organization"]) ? row["organization"] : null,
+		prefill: isRecord(row["prefill"]) ? row["prefill"] : {},
+		extra: extraOf(row, PREVIEW_KEYS)
+	};
+}
+const disabledAtOf = (row) => {
+	const disabledAt = optionalText(row["disabled_at"]);
+	return disabledAt === null ? {} : { disabledAt: temporal().Instant.from(disabledAt) };
+};
+function recordOf(value, fn) {
+	if (!isRecord(value)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
+	return value;
+}
+const MEMBERSHIP_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"name",
+	"slug",
+	"role",
+	"disabledAt"
+]);
+/** Splits `name` and `slug`, which the block types, from the extra columns `fields` checks. */
+const splitAttributes = (attributes) => {
+	const { name, slug, ...extra } = attributes;
+	return {
+		base: {
+			...name === void 0 ? {} : { name },
+			...slug === void 0 ? {} : { slug }
+		},
+		extra
+	};
+};
+/** Calls the `organizations` and `invitations` block functions. */
+function createOrganizations(options) {
+	const client = organizationsClient(options);
+	return withBlockHooks(client, options.hooks, {
+		block: "organizations",
+		...options.events ? { logger: options.events.logger } : {}
+	});
+}
+function organizationsClient(options) {
+	applyTemporal(options);
+	const fields = blockFields(options.fields, "organization fields");
+	const checked = (attributes) => AsyncResult.from(async () => {
+		const { base, extra } = splitAttributes(attributes);
+		const result = await fields.write(extra);
+		return result.ok ? ok({
+			...result.data,
+			...base
+		}) : result;
+	});
+	const { transport } = options;
+	const schemaOf = (module) => typeof options.schema === "string" ? options.schema : options.schema?.[module] ?? "better_supabase";
+	const mappers = options.mappers ?? [];
+	const calls = {
+		organizations: blockCall(transport, schemaOf("organizations"), mappers),
+		invitations: blockCall(transport, schemaOf("invitations"), mappers)
+	};
+	function run(module, fn, args, then) {
+		return calls[module](fn, args, then);
+	}
+	function emit(type, data, subject, tenant) {
+		if (!options.events) return;
+		emitBlockEvent(options.events, type, data, {
+			subject,
+			...tenant ? { tenant } : {},
+			...options.actorId ? { actorId: options.actorId } : {},
+			...options.context ? { context: options.context } : {}
+		});
+	}
+	const organizationEvent = (type, data) => {
+		emit(type, data, `organizations/${data.organizationId}`, data.organizationId);
+	};
+	const invitationEvent = (type, data) => {
+		emit(type, data, `invitations/${data.invitationId}`, data.organizationId ?? null);
+	};
+	const sent = async (value, fn, resent) => {
+		const row = recordOf(value, fn);
+		const invitation = invitationFrom(row);
+		const result = {
+			invitation,
+			token: text(row["token"]),
+			resent
+		};
+		invitationEvent(resent ? "invitation.resent" : "invitation.created", {
+			invitationId: invitation.id,
+			...invitation.organizationId === null ? {} : { organizationId: invitation.organizationId },
+			email: invitation.email,
+			role: invitation.role
+		});
+		await options.onInvite?.(result);
+		return result;
+	};
+	const accepted = (value) => {
+		const organizationId = optionalText(value);
+		if (organizationId !== null) organizationEvent("organization.member_added", {
+			organizationId,
+			...options.actorId ? { userId: options.actorId } : {}
+		});
+		return { organizationId };
+	};
+	return {
+		create(attributes, createOptions) {
+			return checked(attributes).andThen((valid) => {
+				return run("organizations", "create_organization", { attrs: {
+					...valid,
+					...createOptions?.ownerId ? { owner_id: createOptions.ownerId } : {}
+				} }, (value) => {
+					const id = text(value);
+					organizationEvent("organization.created", {
+						organizationId: id,
+						...createOptions?.ownerId ?? options.actorId ? { userId: createOptions?.ownerId ?? options.actorId } : {}
+					});
+					return { id };
+				});
+			});
+		},
+		update(organizationId, attributes) {
+			return checked(attributes).andThen((valid) => run("organizations", "update_organization", {
+				organization: organizationId,
+				attrs: valid
+			}, () => {
+				organizationEvent("organization.updated", { organizationId });
+				return true;
+			}));
+		},
+		delete(organizationId) {
+			return run("organizations", "delete_organization", { organization: organizationId }, (value) => {
+				if (value === true) organizationEvent("organization.deleted", { organizationId });
+				return value === true;
+			});
+		},
+		slugProblem(slug, exceptOrganizationId) {
+			return run("organizations", "organization_slug_problem", {
+				value: slug,
+				except_organization: exceptOrganizationId
+			}, (value) => {
+				if (value === null) return;
+				if (value === "invalid" || value === "reserved" || value === "taken") return value;
+				throw new TypeError(`Unknown slug problem ${String(value)}`);
+			});
+		},
+		updateMemberRole(organizationId, userId, role) {
+			return run("organizations", "update_member_role", {
+				organization: organizationId,
+				member: userId,
+				role
+			}, () => {
+				organizationEvent("organization.role_changed", {
+					organizationId,
+					userId,
+					role
+				});
+				return true;
+			});
+		},
+		removeMember(organizationId, userId) {
+			return run("organizations", "remove_member", {
+				organization: organizationId,
+				member: userId
+			}, () => {
+				organizationEvent("organization.member_removed", {
+					organizationId,
+					userId
+				});
+				return true;
+			});
+		},
+		suspendMember(organizationId, userId) {
+			return run("organizations", "suspend_member", {
+				organization: organizationId,
+				member: userId
+			}, (value) => {
+				if (value === true) organizationEvent("organization.member_suspended", {
+					organizationId,
+					userId
+				});
+				return value === true;
+			});
+		},
+		resumeMember(organizationId, userId) {
+			return run("organizations", "resume_member", {
+				organization: organizationId,
+				member: userId
+			}, (value) => {
+				if (value === true) organizationEvent("organization.member_resumed", {
+					organizationId,
+					userId
+				});
+				return value === true;
+			});
+		},
+		leave(organizationId) {
+			return run("organizations", "leave_organization", { organization: organizationId }, () => {
+				organizationEvent("organization.member_left", {
+					organizationId,
+					...options.actorId ? { userId: options.actorId } : {}
+				});
+				return true;
+			});
+		},
+		transferOwnership(organizationId, newOwnerId, formerRole) {
+			return run("organizations", "transfer_ownership", {
+				organization: organizationId,
+				new_owner: newOwnerId,
+				former_role: formerRole
+			}, () => {
+				organizationEvent("organization.ownership_transferred", {
+					organizationId,
+					userId: newOwnerId
+				});
+				return true;
+			});
+		},
+		markUsed(organizationId) {
+			return run("organizations", "mark_used", { organization: organizationId }, (value) => value === true);
+		},
+		switch(organizationId) {
+			return run("organizations", "switch_organization", { organization: organizationId }, (value) => {
+				const row = recordOf(value, "switch_organization");
+				organizationEvent("organization.switched", {
+					organizationId,
+					...options.actorId ? { userId: options.actorId } : {}
+				});
+				return {
+					organizationId: text(row["organization_id"]),
+					refresh: row["refresh"] === true
+				};
+			});
+		},
+		mine() {
+			return run("organizations", "list_my_organizations", {}, (value) => recordsOf(value, "list_my_organizations")).andThen(async (rows) => {
+				const memberships = [];
+				for (const row of rows) {
+					const attributes = isRecord(row["attributes"]) ? Object.fromEntries(Object.entries(row["attributes"]).filter(([key]) => !MEMBERSHIP_KEYS.has(key))) : {};
+					const parsed = await fields.read(attributes);
+					if (!parsed.ok) return parsed;
+					const slug = optionalText(row["slug"]);
+					memberships.push({
+						...parsed.data,
+						id: text(row["id"]),
+						name: text(row["name"]),
+						...slug === null ? {} : { slug },
+						role: text(row["role"]),
+						...disabledAtOf(row)
+					});
+				}
+				return ok(memberships);
+			});
+		},
+		members(organizationId) {
+			return run("organizations", "list_members", { organization: organizationId }, (value) => recordsOf(value, "list_members").map((row) => ({
+				userId: text(row["user_id"]),
+				role: text(row["role"]),
+				...disabledAtOf(row)
+			})));
+		},
+		invitations(organizationId) {
+			return run("organizations", "list_organization_invitations", { organization: organizationId }, (value) => recordsOf(value, "list_organization_invitations").map((row) => {
+				const expiresAt = optionalText(row["expires_at"]);
+				return {
+					id: text(row["id"]),
+					email: text(row["email"]),
+					role: text(row["role"]),
+					...expiresAt === null ? {} : { expiresAt: temporal().Instant.from(expiresAt) }
+				};
+			}));
+		},
+		invite(request) {
+			return AsyncResult.from(async () => {
+				if (options.canInvite && !await options.canInvite(request)) return err(dbError("forbidden", "The invitation was refused", { hint: "INVITATION_FORBIDDEN" }));
+				return run("invitations", "invite_member", {
+					tenant: request.organizationId,
+					invitee_email: request.email,
+					invitee_role: request.role,
+					valid_for: request.validFor,
+					prefill: request.prefill
+				}, (value) => sent(value, "invite_member", false));
+			});
+		},
+		resendInvitation(invitationId, validFor) {
+			return run("invitations", "resend_invitation", {
+				invitation_id: invitationId,
+				valid_for: validFor
+			}, (value) => sent(value, "resend_invitation", true));
+		},
+		updateInvitation(invitationId, changes) {
+			return run("invitations", "update_invitation", {
+				invitation_id: invitationId,
+				invitee_email: changes.email,
+				invitee_role: changes.role,
+				prefill: changes.prefill
+			}, (value) => {
+				const invitation = invitationFrom(recordOf(value, "update_invitation"));
+				invitationEvent("invitation.updated", {
+					invitationId: invitation.id,
+					...invitation.organizationId === null ? {} : { organizationId: invitation.organizationId },
+					email: invitation.email,
+					role: invitation.role
+				});
+				return invitation;
+			});
+		},
+		revokeInvitation(invitationId) {
+			return run("invitations", "revoke_invitation", { invitation_id: invitationId }, (value) => {
+				if (value === true) invitationEvent("invitation.revoked", { invitationId });
+				return value === true;
+			});
+		},
+		declineInvitation(token) {
+			return run("invitations", "decline_invitation", { token }, (value) => value === true);
+		},
+		previewInvitation(token) {
+			return run("invitations", "invitation_preview", { token }, (value) => value === null ? void 0 : previewFrom(recordOf(value, "invitation_preview")));
+		},
+		acceptInvitation(token) {
+			return run("invitations", "accept_invitation", { token }, accepted);
+		},
+		acceptInvitationById(invitationId) {
+			return run("invitations", "accept_invitation_by_id", { invitation_id: invitationId }, accepted);
+		},
+		myInvitations() {
+			return run("invitations", "my_invitations", {}, (value) => (Array.isArray(value) ? value.filter(isRecord) : []).map(invitationFrom));
+		},
+		declineInvitationById(invitationId) {
+			return run("invitations", "decline_invitation_by_id", { invitation_id: invitationId }, (value) => value === true);
+		}
+	};
+}
+//#endregion
+export { createOrganizations, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -0,0 +1,3 @@
+import { t as SqlClient } from "../../executor-DbvExCFC.js";
+import { a as OutboxEvent, c as OutboxPurgeOptions, d as RegisterOptions, f as RelayOptions, h as outboxCloudEvent, i as OutboxDeadLetter, l as OutboxRouteOptions, m as createOutbox, n as HistoryFilter, o as OutboxHandler, p as RelayResult, r as Outbox, s as OutboxOptions, t as EmitOptions, u as OutboxRouteResult } from "../../outbox-Cq7pPYvl.js";
+export { type EmitOptions, type HistoryFilter, type Outbox, type OutboxDeadLetter, type OutboxEvent, type OutboxHandler, type OutboxOptions, type OutboxPurgeOptions, type OutboxRouteOptions, type OutboxRouteResult, type RegisterOptions, type RelayOptions, type RelayResult, type SqlClient, createOutbox, outboxCloudEvent };

package/dist/blocks/outbox/index.js

@@ -0,0 +1,266 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { s as toDbError } from "../../result-DzUbqgdW.js";
+import { a as problemResponse } from "../../problem-BreOl8b8.js";
+import { r as sqlIdent } from "../../template--jDkl3UP.js";
+import { A as workerId, C as run, g as pageOf, k as toInstant, n as applyTemporal, r as asDbError } from "../../block-helpers-DWHxHsEQ.js";
+import { l as verifySharedSecret } from "../../verify-DL41hbvY.js";
+//#region src/blocks/outbox/outbox.ts
+function isOutboxRow(value) {
+	return typeof value === "object" && value !== null && "position" in value && "type" in value && "created_at" in value;
+}
+function toEvent(row) {
+	return {
+		position: row.position,
+		id: String(row.id),
+		type: row.type,
+		payload: row.payload,
+		source: row.source ?? null,
+		subject: row.subject ?? null,
+		tenant: row.tenant === void 0 || row.tenant === null ? null : String(row.tenant),
+		key: row.key ?? null,
+		actorId: row.actor_id ?? null,
+		createdAt: toInstant(row.created_at)
+	};
+}
+function toEvents(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(isOutboxRow).map(toEvent);
+}
+/**
+* The CloudEvent for an outbox row: the row id as `id` (stable, so receivers
+* can deduplicate), the payload as `data`, the tenant as `partitionkey` and
+* the writing module as `producer`. The actor stays out of the context
+* attributes, which must not carry personal data.
+*/
+function outboxCloudEvent(event, options) {
+	return {
+		specversion: "1.0",
+		id: event.id,
+		source: options.source,
+		type: `${options.typePrefix ?? "dev.better-supabase"}.${event.type}`,
+		...event.subject ? { subject: event.subject } : {},
+		time: event.createdAt.toString(),
+		datacontenttype: "application/json",
+		data: event.payload,
+		...event.tenant ? { partitionkey: event.tenant } : {},
+		...event.source ? { producer: event.source } : {}
+	};
+}
+/** The outbox functions' argument names, for calls through a `BlockTransport`. */
+const PARAMS = {
+	emit_event: [
+		"event_type",
+		"payload",
+		"subject",
+		"tenant",
+		"key",
+		"source"
+	],
+	outbox_register: [
+		"consumer",
+		"types",
+		"from_start"
+	],
+	outbox_unregister: ["consumer"],
+	outbox_claim: [
+		"consumer",
+		"owner",
+		"max_events",
+		"lease"
+	],
+	outbox_ack: [
+		"consumer",
+		"owner",
+		"upto"
+	],
+	outbox_fail: [
+		"consumer",
+		"owner",
+		"failed",
+		"error",
+		"max_attempts",
+		"max_backoff"
+	],
+	outbox_dead_letters: ["consumer", "max_rows"],
+	outbox_history: [
+		"subject",
+		"event_type",
+		"after",
+		"max_events"
+	],
+	purge_outbox: [
+		"older_than",
+		"batch",
+		"ignore_idle"
+	]
+};
+function toDeadLetters(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		if (typeof entry !== "object" || entry === null) return [];
+		const row = { ...entry };
+		const event = row["event"];
+		if (!isOutboxRow(event)) return [];
+		return [{
+			consumer: String(row["consumer"]),
+			event: toEvent(event),
+			attempts: Number(row["attempts"] ?? 0),
+			error: typeof row["error"] === "string" ? row["error"] : null,
+			deadAt: toInstant(String(row["dead_at"]))
+		}];
+	});
+}
+const isTransport = (source) => "call" in source;
+/**
+* The outbox over a server connection (`SqlClient`), or over a
+* `BlockTransport` such as `rpcTransport(serviceClient, { schema: "api" })`
+* for apps that reach the database only through the Data API. Over a
+* transport, `emit` writes in its own transaction.
+*/
+function createOutbox(source, options) {
+	applyTemporal(options);
+	const name = options.schema ?? "better_supabase";
+	const schema = sqlIdent(name);
+	const transport = isTransport(source) ? source : void 0;
+	const call = async (fn, args) => {
+		if (isTransport(source)) {
+			const names = PARAMS[fn] ?? [];
+			return await source.call(name, fn, Object.fromEntries(names.map((param, index) => [param, args[index]]))) ?? null;
+		}
+		const sql = source;
+		const params = args.map((_, index) => `$${String(index + 1)}`).join(", ");
+		const [row] = await sql.queryRaw(`select ${schema}.${sqlIdent(fn)}(${params}) as value`, args);
+		return row?.value ?? null;
+	};
+	const toSink = (sink) => (events) => sink.send(events.map((event) => outboxCloudEvent(event, options)));
+	async function relay(consumer, handler, relayOptions = {}, deadline) {
+		const owner = relayOptions.owner ?? workerId();
+		const batch = relayOptions.batch ?? 100;
+		const lease = relayOptions.lease ?? "1 minute";
+		const until = deadline ?? (relayOptions.budgetMs === void 0 ? Number.POSITIVE_INFINITY : Date.now() + relayOptions.budgetMs);
+		let delivered = 0;
+		while (Date.now() < until) {
+			let events;
+			try {
+				events = toEvents(await call("outbox_claim", [
+					consumer,
+					owner,
+					batch,
+					lease
+				]));
+			} catch (cause) {
+				return {
+					delivered,
+					error: asDbError(cause)
+				};
+			}
+			const last = events.at(-1);
+			if (last === void 0) {
+				await call("outbox_ack", [
+					consumer,
+					owner,
+					null
+				]).catch(() => null);
+				break;
+			}
+			try {
+				await handler(events);
+			} catch (cause) {
+				const error = toDbError(cause);
+				return await call("outbox_fail", [
+					consumer,
+					owner,
+					events.length === 1 ? last.position : null,
+					error.message,
+					relayOptions.maxAttempts ?? 10,
+					relayOptions.maxBackoff ?? "10 minutes"
+				]).catch(() => null) === "dead" ? {
+					delivered,
+					error,
+					deadLettered: 1
+				} : {
+					delivered,
+					error
+				};
+			}
+			try {
+				await call("outbox_ack", [
+					consumer,
+					owner,
+					last.position
+				]);
+			} catch (cause) {
+				return {
+					delivered,
+					error: asDbError(cause)
+				};
+			}
+			delivered += events.length;
+			if (events.length < batch) break;
+		}
+		return { delivered };
+	}
+	return {
+		emit: (type, payload = {}, emitOptions = {}) => run(async () => String(await call("emit_event", [
+			type,
+			transport ? payload : JSON.stringify(payload),
+			emitOptions.subject ?? null,
+			emitOptions.tenant ?? null,
+			emitOptions.key ?? null,
+			emitOptions.source ?? null
+		]))),
+		register: (consumer, registerOptions = {}) => run(async () => Number(await call("outbox_register", [
+			consumer,
+			registerOptions.types ?? null,
+			registerOptions.fromStart ?? false
+		]))),
+		unregister: (consumer) => run(async () => await call("outbox_unregister", [consumer]) === true),
+		relay: (consumer, sink, relayOptions) => relay(consumer, toSink(sink), relayOptions),
+		consume: (consumer, handler, relayOptions) => relay(consumer, handler, relayOptions),
+		relayRoute(routeOptions) {
+			const secret = routeOptions.secret;
+			if (!secret) throw new TypeError("relayRoute needs a secret, such as process.env.CRON_SECRET");
+			return async (request) => {
+				const instance = new URL(request.url).pathname;
+				if (request.method !== "GET" && request.method !== "POST") return new Response(null, {
+					status: 405,
+					headers: { allow: "GET, POST" }
+				});
+				if (!verifySharedSecret(request, secret)) return problemResponse(dbError("unauthorized", "The relay route needs its bearer secret"), {
+					instance,
+					format: routeOptions.problem
+				});
+				const deadline = Date.now() + (routeOptions.budgetMs ?? 5e4);
+				const entries = Object.entries(routeOptions.consumers);
+				const relayed = await Promise.all(entries.map(async ([consumer, sink]) => {
+					const result = await relay(consumer, typeof sink === "function" ? sink : toSink(sink), routeOptions, deadline);
+					if (result.error) routeOptions.onError?.(result.error, consumer);
+					return result;
+				}));
+				const results = {};
+				entries.forEach(([consumer], index) => {
+					results[consumer] = relayed[index];
+				});
+				const result = {
+					consumers: results,
+					budgetExhausted: Date.now() >= deadline
+				};
+				return Response.json(result);
+			};
+		},
+		history: (filter = {}) => run(async () => toEvents(await call("outbox_history", [
+			filter.subject ?? null,
+			filter.type ?? null,
+			pageOf(filter).cursor ?? 0,
+			filter.limit ?? 100
+		]))),
+		deadLetters: (consumer, limit) => run(async () => toDeadLetters(await call("outbox_dead_letters", [consumer, limit ?? 100]))),
+		purge: (olderThan, batch, purgeOptions = {}) => run(async () => Number(await call("purge_outbox", [
+			olderThan ?? null,
+			batch ?? null,
+			purgeOptions.ignoreIdle ?? null
+		])))
+	};
+}
+//#endregion
+export { createOutbox, outboxCloudEvent };