better-supabase 0.3.0 → 0.5.0

package/dist/notifications/index.js

@@ -0,0 +1,264 @@
+import { c as mapDbError, n as dbError } from "../errors-DtwXa6b8.js";
+import { t as temporal } from "../temporal-required-CAt4Dc9Z.js";
+import { i as ok, n as err, o as toDbError, t as AsyncResult } from "../result-BKiliPY7.js";
+import { t as validate } from "../standard-D7r6dMUu.js";
+import { n as emitKitEvent } from "../kit-events-CTFDfSwb.js";
+import { n as rpcTransport, r as sqlTransport, t as rawError } from "../kit-transport-DJlHQUBU.js";
+//#region src/notifications/notifications.ts
+const DEFAULT_SCHEMA = "better_supabase";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const textOf = (value) => value === null || value === void 0 ? null : String(value);
+const instantOf = (value) => typeof value === "string" ? temporal().Instant.from(value) : null;
+function toItem(row) {
+	const type = textOf(row["subject_type"]);
+	const id = textOf(row["subject_id"]);
+	const label = textOf(row["subject_label"]);
+	return {
+		id: String(row["id"]),
+		eventId: String(row["event_id"]),
+		type: String(row["type"]),
+		data: row["data"] ?? {},
+		tenant: textOf(row["tenant"]),
+		actorId: textOf(row["actor_id"]),
+		subject: type === null || id === null ? null : {
+			type,
+			id,
+			...label === null ? {} : { label }
+		},
+		summary: textOf(row["summary"]),
+		actionPath: textOf(row["action_path"]),
+		priority: textOf(row["priority"]),
+		createdAt: instantOf(row["created_at"]) ?? temporal().Now.instant(),
+		readAt: instantOf(row["read_at"]),
+		resolvedAt: instantOf(row["resolved_at"])
+	};
+}
+function cursorOf(before) {
+	if (before === void 0) return {
+		before: null,
+		before_id: null
+	};
+	if ("epochNanoseconds" in before) return {
+		before: before.toString(),
+		before_id: null
+	};
+	return {
+		before: before.createdAt.toString(),
+		before_id: before.id
+	};
+}
+const errorText = (cause) => cause instanceof Error ? cause.message : String(cause);
+function createNotifications(options) {
+	const { transport } = options;
+	const schema = options.schema ?? DEFAULT_SCHEMA;
+	const mappers = options.errorMappers ?? [];
+	const call = async (fn, args) => transport.call(schema, fn, args);
+	function run(fn, args, then) {
+		return AsyncResult.from(async () => {
+			let value;
+			try {
+				value = await call(fn, args);
+			} catch (cause) {
+				const raw = rawError(cause);
+				return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
+			}
+			return ok(await then(value));
+		});
+	}
+	function emit(type, data, tenant) {
+		if (!options.events) return;
+		emitKitEvent(options.events, type, data, {
+			subject: `notifications/${data.notificationId}`,
+			...tenant ? { tenant } : {},
+			...options.actorId ? { actorId: options.actorId } : {},
+			...options.context ? { context: options.context } : {}
+		});
+	}
+	const render = (item, locale) => {
+		if (!options.render) return item;
+		return {
+			...item,
+			text: options.render(item, locale === void 0 ? {} : { locale })
+		};
+	};
+	async function deliverOne(channel, row, maxAttempts) {
+		const notification = isRecord(row["notification"]) ? toItem(row["notification"]) : void 0;
+		if (!notification) throw new TypeError("claim returned no notification");
+		const attempts = Number(row["attempts"] ?? 1);
+		const message = {
+			deliveryId: String(row["delivery_id"]),
+			channel: channel.name,
+			attempts,
+			userId: String(row["user_id"]),
+			email: textOf(row["email"]),
+			notification,
+			...options.render ? { text: options.render(notification, {}) } : {}
+		};
+		try {
+			const result = await channel.send(message);
+			const status = result?.status ?? "sent";
+			await call("complete_notification_delivery", {
+				delivery: message.deliveryId,
+				status,
+				provider: result?.provider ?? null,
+				provider_message_id: result?.providerMessageId ?? null
+			});
+			if (status === "sent") emit("notification.delivered", {
+				notificationId: notification.eventId,
+				type: notification.type,
+				channel: channel.name
+			}, notification.tenant);
+			return status;
+		} catch (cause) {
+			const error = errorText(cause);
+			await call("complete_notification_delivery", {
+				delivery: message.deliveryId,
+				status: "pending",
+				error,
+				max_attempts: maxAttempts
+			});
+			emit("notification.failed", {
+				notificationId: notification.eventId,
+				type: notification.type,
+				channel: channel.name,
+				error
+			}, notification.tenant);
+			return "failed";
+		}
+	}
+	return {
+		send(type, input) {
+			return AsyncResult.from(async () => {
+				const schemaOf = Object.hasOwn(options.types, type) ? options.types[type] : void 0;
+				if (schemaOf === void 0) return err(dbError("validation", `Unknown notification type "${type}"`, {
+					issues: [{
+						path: ["type"],
+						message: `Unknown type "${type}"`
+					}],
+					hint: "NOTIFICATION_TYPE_UNKNOWN"
+				}));
+				const data = await validate(schemaOf, input.data, `${type} data`);
+				if (!data.ok) return err(data.error);
+				const sent = await run("notify", { notification: {
+					type,
+					data: data.data,
+					recipients: input.recipients ?? [],
+					tenant: input.tenant,
+					subject_type: input.subject?.type,
+					subject_id: input.subject?.id,
+					subject_label: input.subject?.label,
+					summary: input.summary,
+					action_path: input.actionPath,
+					priority: input.priority,
+					key: input.key,
+					channels: input.channels,
+					include_actor: input.includeActor,
+					activity: input.activity,
+					resolved: input.resolved,
+					actor: input.actorId
+				} }, (value) => value === null ? null : String(value));
+				if (!sent.ok || sent.data === null) return sent;
+				const recipients = input.recipients ?? [];
+				emit("notification.created", {
+					notificationId: sent.data,
+					type,
+					recipientIds: recipients
+				}, input.tenant ?? null);
+				if (options.onSent) try {
+					await options.onSent({
+						id: sent.data,
+						type,
+						tenant: input.tenant ?? null,
+						recipients
+					});
+				} catch (cause) {
+					return err(toDbError(cause));
+				}
+				return sent;
+			});
+		},
+		list(listOptions = {}) {
+			return run("list_notifications", {
+				tenant: listOptions.tenant ?? null,
+				status: listOptions.status ?? "all",
+				types: listOptions.types ?? null,
+				...cursorOf(listOptions.before),
+				max_items: listOptions.limit ?? 50
+			}, (value) => (Array.isArray(value) ? value : []).filter(isRecord).map((row) => render(toItem(row), listOptions.locale)));
+		},
+		counts(countOptions = {}) {
+			return run("notification_counts", {
+				tenant: countOptions.tenant ?? null,
+				actionable: options.actionable ?? []
+			}, (value) => ({
+				unread: Number(isRecord(value) ? value["unread"] ?? 0 : 0),
+				actionable: Number(isRecord(value) ? value["actionable"] ?? 0 : 0)
+			}));
+		},
+		markRead(readOptions = {}) {
+			return run("mark_notifications_read", {
+				ids: readOptions.ids ?? null,
+				tenant: readOptions.tenant ?? null
+			}, Number);
+		},
+		dismiss(ids) {
+			return run("dismiss_notifications", { ids }, Number);
+		},
+		resolve(input) {
+			return run("resolve_notifications", {
+				type: input.type,
+				subject_type: input.subject.type,
+				subject_id: input.subject.id,
+				tenant: input.tenant ?? null
+			}, Number);
+		},
+		subscribe(input) {
+			return run("set_notification_subscription", {
+				subject_type: input.subject.type,
+				subject_id: input.subject.id,
+				level: input.level,
+				tenant: input.tenant ?? null,
+				member: input.userId ?? null
+			}, () => void 0);
+		},
+		setPreference(input) {
+			return run("set_notification_preference", {
+				type: input.type,
+				channel: input.channel,
+				enabled: input.enabled,
+				tenant: input.tenant ?? null
+			}, () => void 0);
+		},
+		async deliver(deliverOptions = {}) {
+			const wanted = deliverOptions.channels;
+			const channels = (options.channels ?? []).filter((channel) => !wanted || wanted.includes(channel.name));
+			const deadline = deliverOptions.budgetMs === void 0 ? Number.POSITIVE_INFINITY : Date.now() + deliverOptions.budgetMs;
+			const batch = deliverOptions.batch ?? 50;
+			const counts = {
+				sent: 0,
+				skipped: 0,
+				failed: 0
+			};
+			for (const channel of channels) while (Date.now() < deadline) {
+				const claimed = await call("claim_notification_deliveries", {
+					channel: channel.name,
+					max_items: batch,
+					lease: deliverOptions.lease ?? "5 minutes",
+					max_attempts: deliverOptions.maxAttempts ?? 5
+				});
+				const rows = (Array.isArray(claimed) ? claimed : []).filter(isRecord);
+				for (const row of rows) counts[await deliverOne(channel, row, deliverOptions.maxAttempts ?? 5)] += 1;
+				if (rows.length < batch) break;
+			}
+			return counts;
+		},
+		purge(olderThan, batch) {
+			return run("purge_notifications", {
+				older_than: olderThan ?? null,
+				batch: batch ?? null
+			}, Number);
+		}
+	};
+}
+//#endregion
+export { createNotifications, rpcTransport, sqlTransport };

package/dist/openapi/index.d.ts

@@ -1,2 +1,2 @@
-import { a as ResourceOptions, i as ResourceOperation, n as OpenApiOptions, o as createOpenApi, r as PROBLEM_SCHEMA, t as OpenApiDocument } from "../index-qriRM9cZ.js";
+import { a as ResourceOptions, i as ResourceOperation, n as OpenApiOptions, o as createOpenApi, r as PROBLEM_SCHEMA, t as OpenApiDocument } from "../index-C7f8cOBM.js";
 export { OpenApiDocument, OpenApiOptions, PROBLEM_SCHEMA, ResourceOperation, ResourceOptions, createOpenApi };

package/dist/openapi/index.js

@@ -1,6 +1,6 @@
-import { n as PROBLEM_TYPE_BASE, t as PROBLEM_CONTENT_TYPE } from "../problem-CGt1ADix.js";
+import { n as PROBLEM_TYPE_BASE, t as PROBLEM_CONTENT_TYPE } from "../problem-BW1KhzSG.js";
 import { t as SPEC_PINS } from "../spec-pins-C3oc-Tdp.js";
-import { t as buildJsonSchema } from "../json-schema--aOXAGfU.js";
+import { t as buildJsonSchema } from "../json-schema-m1fiwKgN.js";
 //#region src/openapi/index.ts
 /** JSON Schema for RFC 9457 Problem Details as better-supabase sends them. */
 const PROBLEM_SCHEMA = {
@@ -173,15 +173,15 @@ function pageSchema(row, cursor) {
 * schemes and Problem Details errors.
 *
 * ```ts
-* const doc = createOpenApi(sb, {
+* const doc = createOpenApi(betterSupabase, {
 *   info: { title: 'CRM API', version: '1.0.0' },
 *   resources: { customers: { list: customerList }, notes: { operations: ['list', 'get'] } },
 * });
 * ```
 */
-function createOpenApi(sb, options) {
+function createOpenApi(betterSupabase, options) {
 	const defs = buildJsonSchema({
-		meta: sb.meta,
+		meta: betterSupabase.meta,
 		config: { json: options.json ?? {} }
 	})["$defs"];
 	const schemas = { Problem: PROBLEM_SCHEMA };
@@ -190,7 +190,7 @@ function createOpenApi(sb, options) {
 	const base = (options.basePath ?? "").replace(/\/$/, "");
 	const security = options.security ?? ["bearer"];
 	for (const [key, raw] of Object.entries(options.resources)) {
-		const table = sb.meta.tables[key];
+		const table = betterSupabase.meta.tables[key];
 		if (!table) throw new TypeError(`createOpenApi: unknown table "${key}"`);
 		const resource = raw === true ? {} : raw;
 		const operations = resource.operations ?? (table.kind === "view" ? ["list", "get"] : [

package/dist/orgs/index.d.ts

@@ -0,0 +1,132 @@
+/// <reference lib="esnext.temporal" />
+import { S as ErrorMapper, a as AsyncResult } from "../executor-BunPOO-k.js";
+import { a as EventHub } from "../events-aIO7vsIk.js";
+import { g as RequestContext } from "../plugin-o144f322.js";
+import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as KitTransport } from "../kit-transport-B82k1djG.js";
+//#region src/orgs/orgs.d.ts
+/**
+ * Organization columns by database name: `name`, `slug` and the columns in
+ * `kits.organizations.options.attributes`. Other keys are ignored.
+ */
+interface OrgAttributes {
+  readonly name?: string;
+  readonly slug?: string;
+  readonly [column: string]: unknown;
+}
+interface CreateOrgOptions {
+  /** The owner, when the transport runs as the service role. */
+  readonly ownerId?: string;
+}
+type SlugProblem = "invalid" | "reserved" | "taken";
+interface InviteRequest {
+  /** `null` invites to the platform (`kits.access.model: 'catalog'`). */
+  readonly organizationId: string | null;
+  readonly email: string;
+  /** A role name, or a role id or key under the catalog model. */
+  readonly role: string;
+  /** A Postgres interval such as `'3 days'`. Defaults to `options.validFor`. */
+  readonly validFor?: string;
+  /** Profile fields to fill in on sign-up. */
+  readonly prefill?: Readonly<Record<string, unknown>>;
+}
+interface Invitation {
+  readonly id: string;
+  readonly organizationId: string | null;
+  readonly email: string;
+  readonly role: string;
+  readonly expiresAt: Temporal.Instant;
+  readonly invitedBy?: string;
+  readonly prefill: Readonly<Record<string, unknown>>;
+}
+/** What `onInvite` receives: the place to send the email. */
+interface InvitationSent {
+  readonly invitation: Invitation;
+  /** Put it in the accept link. It is never stored in plain text by default. */
+  readonly token: string;
+  readonly resent: boolean;
+}
+type InvitationStatus = "pending" | "accepted" | "declined" | "revoked" | "expired";
+interface InvitationPreview {
+  readonly status: InvitationStatus;
+  readonly email: string;
+  readonly role: string;
+  readonly organizationId: string | null;
+  readonly expiresAt: Temporal.Instant;
+  /** The organization columns in `options.previewColumns`. */
+  readonly organization: Readonly<Record<string, unknown>> | null;
+  readonly prefill: Readonly<Record<string, unknown>>;
+}
+interface SwitchResult {
+  readonly organizationId: string;
+  /** The active tenant is a claim: refresh the session to get it. */
+  readonly refresh: boolean;
+}
+interface OrgsOptions {
+  /** `sqlTransport(postgres.asUser(claims))` or `rpcTransport(supabase)`. */
+  readonly transport: KitTransport;
+  /**
+   * The schema holding the functions: `kits.<module>.schema` with
+   * `sqlTransport`, the exposed API schema of wrappers with `rpcTransport`.
+   * One schema for both modules, or one per module. Defaults to
+   * `better_supabase`.
+   */
+  readonly schema?: string | {
+    readonly organizations?: string;
+    readonly invitations?: string;
+  };
+  /** `betterSupabase.events`, to emit `org.*` and `invitation.*` kit events. */
+  readonly events?: EventHub;
+  /** The user acting, for event metadata. */
+  readonly actorId?: string;
+  readonly context?: RequestContext;
+  /**
+   * Runs before an invitation is created, after the database checks the
+   * caller may invite. Return `false` to refuse (seat limits, plans).
+   */
+  readonly canInvite?: (request: InviteRequest) => boolean | Promise<boolean>;
+  /**
+   * Runs after an invitation is created or resent, to send the email. When
+   * it throws, the call returns an error and the invitation stays open:
+   * call `resendInvitation` to retry.
+   */
+  readonly onInvite?: (sent: InvitationSent) => void | Promise<void>;
+  /** Run before the built-in mapping, as in `betterSupabase.mapError()`. */
+  readonly errorMappers?: readonly ErrorMapper[];
+}
+/**
+ * The `organizations` and `invitations` SQL kit modules as typed calls. Each
+ * method returns an `AsyncResult`; database errors carry the kit's error
+ * code (`ORG_FORBIDDEN`, `INVITATION_INVALID`) as `hint`.
+ */
+interface Orgs {
+  create(attributes: OrgAttributes, options?: CreateOrgOptions): AsyncResult<{
+    readonly id: string;
+  }>;
+  update(organizationId: string, attributes: OrgAttributes): AsyncResult<true>;
+  /** `false` when it did not exist (or was already soft-deleted). */
+  delete(organizationId: string): AsyncResult<boolean>;
+  /** Why a slug can't be used, or `undefined` when it can. */
+  slugProblem(slug: string, exceptOrganizationId?: string): AsyncResult<SlugProblem | undefined>;
+  updateMemberRole(organizationId: string, userId: string, role: string): AsyncResult<true>;
+  removeMember(organizationId: string, userId: string): AsyncResult<true>;
+  leave(organizationId: string): AsyncResult<true>;
+  /** `formerRole` defaults to `options.formerOwnerRole`. */
+  transferOwnership(organizationId: string, newOwnerId: string, formerRole?: string): AsyncResult<true>;
+  markUsed(organizationId: string): AsyncResult<boolean>;
+  switch(organizationId: string): AsyncResult<SwitchResult>;
+  invite(request: InviteRequest): AsyncResult<InvitationSent>;
+  resendInvitation(invitationId: string, validFor?: string): AsyncResult<InvitationSent>;
+  /** `false` when it was not open. */
+  revokeInvitation(invitationId: string): AsyncResult<boolean>;
+  declineInvitation(token: string): AsyncResult<boolean>;
+  /** `undefined` for an unknown token. Callable without a session. */
+  previewInvitation(token: string): AsyncResult<InvitationPreview | undefined>;
+  /** Returns the organization joined, `null` for a platform invitation. */
+  acceptInvitation(token: string): AsyncResult<{
+    readonly organizationId: string | null;
+  }>;
+}
+/** Calls the `organizations` and `invitations` kit functions. */
+export declare function createOrgs(options: OrgsOptions): Orgs;
+//#endregion
+export { type CreateOrgOptions, type Invitation, type InvitationPreview, type InvitationSent, type InvitationStatus, type InviteRequest, type KitTransport, type OrgAttributes, type Orgs, type OrgsOptions, type RpcClient, type SlugProblem, type SwitchResult, rpcTransport, sqlTransport };

package/dist/orgs/index.js

@@ -0,0 +1,245 @@
+import { c as mapDbError, n as dbError } from "../errors-DtwXa6b8.js";
+import { t as temporal } from "../temporal-required-CAt4Dc9Z.js";
+import { i as ok, n as err, o as toDbError, t as AsyncResult } from "../result-BKiliPY7.js";
+import { n as emitKitEvent } from "../kit-events-CTFDfSwb.js";
+import { n as rpcTransport, r as sqlTransport, t as rawError } from "../kit-transport-DJlHQUBU.js";
+//#region src/orgs/orgs.ts
+const DEFAULT_SCHEMA = "better_supabase";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (value) => typeof value === "string" ? value : String(value);
+const optionalText = (value) => value === null || value === void 0 ? null : text(value);
+function invitationFrom(row) {
+	const invitedBy = optionalText(row["invited_by"]);
+	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"])),
+		...invitedBy === null ? {} : { invitedBy },
+		prefill: isRecord(row["prefill"]) ? row["prefill"] : {}
+	};
+}
+const STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"accepted",
+	"declined",
+	"revoked",
+	"expired"
+]);
+function isStatus(value) {
+	return typeof value === "string" && STATUSES.has(value);
+}
+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"] : {}
+	};
+}
+function recordOf(value, fn) {
+	if (!isRecord(value)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
+	return value;
+}
+/** Calls the `organizations` and `invitations` kit functions. */
+function createOrgs(options) {
+	const { transport } = options;
+	const schemaOf = (module) => typeof options.schema === "string" ? options.schema : options.schema?.[module] ?? DEFAULT_SCHEMA;
+	const mappers = options.errorMappers ?? [];
+	function run(module, fn, args, then) {
+		return AsyncResult.from(async () => {
+			let value;
+			try {
+				value = await transport.call(schemaOf(module), fn, args);
+			} catch (cause) {
+				const raw = rawError(cause);
+				return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
+			}
+			return ok(await then(value));
+		});
+	}
+	function emit(type, data, subject, tenant) {
+		if (!options.events) return;
+		emitKitEvent(options.events, type, data, {
+			subject,
+			...tenant ? { tenant } : {},
+			...options.actorId ? { actorId: options.actorId } : {},
+			...options.context ? { context: options.context } : {}
+		});
+	}
+	const orgEvent = (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;
+	};
+	return {
+		create(attributes, createOptions) {
+			return run("organizations", "create_organization", { attrs: {
+				...attributes,
+				...createOptions?.ownerId ? { owner_id: createOptions.ownerId } : {}
+			} }, (value) => {
+				const id = text(value);
+				orgEvent("org.created", {
+					organizationId: id,
+					...createOptions?.ownerId ?? options.actorId ? { userId: createOptions?.ownerId ?? options.actorId } : {}
+				});
+				return { id };
+			});
+		},
+		update(organizationId, attributes) {
+			return run("organizations", "update_organization", {
+				org: organizationId,
+				attrs: attributes
+			}, () => {
+				orgEvent("org.updated", { organizationId });
+				return true;
+			});
+		},
+		delete(organizationId) {
+			return run("organizations", "delete_organization", { org: organizationId }, (value) => {
+				if (value === true) orgEvent("org.deleted", { organizationId });
+				return value === true;
+			});
+		},
+		slugProblem(slug, exceptOrganizationId) {
+			return run("organizations", "organization_slug_problem", {
+				value: slug,
+				except_org: 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", {
+				org: organizationId,
+				member: userId,
+				role
+			}, () => {
+				orgEvent("org.role_changed", {
+					organizationId,
+					userId,
+					role
+				});
+				return true;
+			});
+		},
+		removeMember(organizationId, userId) {
+			return run("organizations", "remove_member", {
+				org: organizationId,
+				member: userId
+			}, () => {
+				orgEvent("org.member_removed", {
+					organizationId,
+					userId
+				});
+				return true;
+			});
+		},
+		leave(organizationId) {
+			return run("organizations", "leave_organization", { org: organizationId }, () => {
+				orgEvent("org.member_left", {
+					organizationId,
+					...options.actorId ? { userId: options.actorId } : {}
+				});
+				return true;
+			});
+		},
+		transferOwnership(organizationId, newOwnerId, formerRole) {
+			return run("organizations", "transfer_ownership", {
+				org: organizationId,
+				new_owner: newOwnerId,
+				former_role: formerRole
+			}, () => {
+				orgEvent("org.ownership_transferred", {
+					organizationId,
+					userId: newOwnerId
+				});
+				return true;
+			});
+		},
+		markUsed(organizationId) {
+			return run("organizations", "mark_used", { org: organizationId }, (value) => value === true);
+		},
+		switch(organizationId) {
+			return run("organizations", "switch_organization", { org: organizationId }, (value) => {
+				const row = recordOf(value, "switch_organization");
+				orgEvent("org.switched", {
+					organizationId,
+					...options.actorId ? { userId: options.actorId } : {}
+				});
+				return {
+					organizationId: text(row["organization_id"]),
+					refresh: row["refresh"] === true
+				};
+			});
+		},
+		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));
+		},
+		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 }, (value) => {
+				const organizationId = optionalText(value);
+				if (organizationId !== null) orgEvent("org.member_added", {
+					organizationId,
+					...options.actorId ? { userId: options.actorId } : {}
+				});
+				return { organizationId };
+			});
+		}
+	};
+}
+//#endregion
+export { createOrgs, rpcTransport, sqlTransport };