better-supabase 0.5.1 → 0.6.0

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

@@ -0,0 +1,200 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
+import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../../types-6BdhkmZe.js";
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
+import { t as BetterSupabase } from "../../define-CJJkkr1-.js";
+import { r as EventSink, t as CloudEvent } from "../../cloud-event-C1JCc1bH.js";
+import { i as ListDefinition } from "../../list-query-BRt-zDF7.js";
+//#region src/blocks/comments/comments.d.ts
+interface CommentsOptions extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema (`sql.modules.comments.schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * The user ids a comment mentions when the call passes no `mentions`,
+   * such as the mention nodes of a rich-text `document`. Default
+   * `mentionsIn(body)`.
+   */
+  readonly mentionsOf?: (comment: {
+    readonly body: string;
+    readonly document: unknown;
+  }) => readonly string[];
+}
+interface Comment {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** `undefined` once the author's account is deleted. */
+  readonly authorId: string | undefined;
+  /** Empty for a deleted comment. */
+  readonly body: string;
+  /** The rich-text document an editor wrote, next to `body` as its plain text. */
+  readonly document: unknown;
+  readonly mentions: readonly string[];
+  readonly parentId: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly editedAt: Temporal.Instant | undefined;
+  readonly deletedAt: Temporal.Instant | undefined;
+}
+interface NewComment {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly body: string;
+  /** A rich-text document (any JSON); keep `body` as its plain text. */
+  readonly document?: unknown;
+  /** User ids; default `mentionsOf`, or the ids `mentionsIn(body)` finds. */
+  readonly mentions?: readonly string[];
+  /** A reply: the parent must be on the same subject. */
+  readonly parentId?: string;
+}
+interface CommentEdit {
+  readonly body: string;
+  /** A new document; `null` removes it, and leaving it out keeps the current one. */
+  readonly document?: unknown;
+  /** Default `mentionsOf`, or the ids `mentionsIn(body)` finds. */
+  readonly mentions?: readonly string[];
+}
+interface ActivityEntry {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly type: string;
+  readonly actorId: string | undefined;
+  readonly subjectType: string | undefined;
+  readonly subjectId: string | undefined;
+  readonly summary: string | undefined;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly occurredAt: Temporal.Instant;
+}
+interface ActivityHistoryOptions extends CursorPageOptions<Temporal.Instant> {
+  /** Entries before this instant, for paging back. */
+  readonly cursor?: Temporal.Instant;
+  /** Default 50, at most 500. */
+  readonly limit?: number;
+}
+interface ListCommentsOptions extends CursorPageOptions<Temporal.Instant> {
+  /** Comments created after this instant, for polling a thread. */
+  readonly cursor?: Temporal.Instant;
+  /** Default 100, at most 500. */
+  readonly limit?: number;
+  /** Comments to skip, for page-number paging. */
+  readonly offset?: number;
+}
+interface Comments {
+  create(comment: NewComment): AsyncResult<Comment>;
+  /** Only the author edits; `not_found` when the caller can't see it. */
+  edit(id: string, edit: CommentEdit): AsyncResult<Comment>;
+  /** Soft-deletes (the author, or a member with `comments.moderate`). */
+  remove(id: string): AsyncResult<boolean>;
+  /** A subject's thread, oldest first, deleted comments as placeholders. */
+  list(organizationId: string, subjectType: string, subjectId: string, options?: ListCommentsOptions): AsyncResult<readonly Comment[]>;
+  /**
+   * How many comments each subject has that the caller can read, deleted
+   * ones left out, such as for a counter on each row of a list. Subjects
+   * without comments are 0.
+   */
+  counts(organizationId: string, subjectType: string, subjectIds: readonly string[]): AsyncResult<Readonly<Record<string, number>>>;
+  /**
+   * Copies a subject's thread to another subject in the tenant, keeping
+   * authors, times and replies; returns how many comments it copied. Needs a
+   * service-role transport.
+   */
+  copy(organizationId: string, from: {
+    readonly type: string;
+    readonly id: string;
+  }, to: {
+    readonly type: string;
+    readonly id: string;
+  }): AsyncResult<number>;
+  /**
+   * The activity feed of a tenant, newest first, or one subject's timeline
+   * with `subject`. Members with `activity.read` see it.
+   */
+  history(organizationId: string, subject?: {
+    readonly type: string;
+    readonly id: string;
+  }, options?: ActivityHistoryOptions): AsyncResult<readonly ActivityEntry[]>;
+}
+/**
+ * The user ids mentioned in a body written as `@[Ada](<user id>)`, the
+ * markup mention inputs produce, in order and without repeats.
+ */
+export declare function mentionsIn(body: string): readonly string[];
+/** Comments over the `comments` module's functions, as the caller. */
+export declare function createComments(options: CommentsOptions): Comments;
+/** What an activity entry says about an event; `null` skips the event. */
+interface ActivityDescription {
+  readonly summary?: string;
+  readonly actorId?: string;
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+interface ActivitySinkOptions {
+  /** A service-role transport: `record_activity()` is granted to `service_role` only. */
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  /** The outbox `typePrefix`, stripped from the stored type. Default `dev.better-supabase`. */
+  readonly typePrefix?: string;
+  /** Types to keep, exact or ending in `.*`. Default every event with a tenant. */
+  readonly types?: readonly string[];
+  /** Summarizes an event, or returns `null` to skip it. */
+  readonly describe?: (event: CloudEvent, type: string) => ActivityDescription | null | undefined;
+}
+/**
+ * An outbox sink that writes events into the activity feed:
+ * `outbox.relay('activity', activitySink({ transport }))`. Events without a
+ * tenant (`partitionkey`) are skipped, and a replayed event writes nothing.
+ */
+export declare function activitySink(options: ActivitySinkOptions): EventSink;
+type ActivitySort = "newest" | "oldest";
+type ActivityFacet = "type" | "actor" | "subjectType" | "subjectId";
+/**
+ * A cursor-paged list over `activity_entries` (generate types for the
+ * `better_supabase` schema to get it in your models), newest first,
+ * filtered by type, actor and subject. Members with `activity.read` see
+ * their tenants' entries.
+ */
+export declare function activityListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, Fn, E>, table: T, options?: {
+  readonly pageSize?: number;
+  readonly maxPageSize?: number;
+}): ListDefinition<M, T, E, ActivitySort, ActivityFacet, false, "cursor">;
+//#endregion
+//#region src/sql/subjects.d.ts
+/**
+ * One subject type a module's rows belong to (`options.subjects`): the
+ * table its ids point at, and who may read it.
+ */
+interface Subject {
+  /** `schema.table`, or a table in `public`. */
+  readonly table: string;
+  /** Default `id`. */
+  readonly id?: string;
+  /**
+   * The id column's type, such as `uuid` or `bigint`. With it, the stored
+   * text id is cast to that type, so the lookup uses the subject table's
+   * primary key; without it the column is cast to text, which can't.
+   */
+  readonly idType?: string;
+  /**
+   * The subject's tenant column, default `organization_id`. `false` for a
+   * subject without a tenant (a user's own records), where the subject
+   * table's policies alone decide, in modules that allow it.
+   */
+  readonly tenant?: string | false;
+  /** A permission the caller also needs in the tenant, e.g. `projects.read`. */
+  readonly permission?: string;
+  /** Delete the module's rows for a subject when the subject row is deleted. */
+  readonly cascade?: boolean;
+  /** The module's own keys, such as a bucket per subject. */
+  readonly extra: Readonly<Record<string, unknown>>;
+}
+//#endregion
+//#region src/sql/modules/comments.d.ts
+/** One commentable subject type: its table, and who may read it. */
+type CommentSubject = Omit<Subject, "extra">;
+//#endregion
+export { type ActivityDescription, type ActivityEntry, type ActivityFacet, type ActivityHistoryOptions, type ActivitySinkOptions, type ActivitySort, type BlockTransport, type Comment, type CommentEdit, type CommentSubject, type Comments, type CommentsOptions, type ListCommentsOptions, type NewComment, rpcTransport, sqlTransport };

package/dist/blocks/comments/index.js

@@ -0,0 +1,207 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as ok, r as err } from "../../result-DzUbqgdW.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { D as stringsOf, O as textOf, d as isRecord, g as pageOf, h as optionalText, i as blockCall, k as toInstant, m as optionalInstant, n as applyTemporal, u as instantArg, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { n as defineListQuery } from "../../list-query-gl808ac1.js";
+//#region src/blocks/comments/comments.ts
+const MENTION = /@\[[^\]\n]{1,100}\]\(([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\)/gi;
+/**
+* The user ids mentioned in a body written as `@[Ada](<user id>)`, the
+* markup mention inputs produce, in order and without repeats.
+*/
+function mentionsIn(body) {
+	return [...new Set([...body.matchAll(MENTION)].flatMap((match) => match[1] ? [match[1].toLowerCase()] : []))];
+}
+function commentOf(value) {
+	const row = recordOf(value, "comments");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		subjectType: textOf(row["subject_type"]),
+		subjectId: textOf(row["subject_id"]),
+		authorId: optionalText(row["author_id"]),
+		body: textOf(row["body"] ?? ""),
+		document: row["document"] ?? null,
+		mentions: stringsOf(row["mentions"]),
+		parentId: optionalText(row["parent_id"]),
+		createdAt: toInstant(textOf(row["created_at"])),
+		editedAt: optionalInstant(row["edited_at"]),
+		deletedAt: optionalInstant(row["deleted_at"])
+	};
+}
+function activityOf(value) {
+	const row = recordOf(value, "activity_entries");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		type: textOf(row["type"]),
+		actorId: optionalText(row["actor_id"]),
+		subjectType: optionalText(row["subject_type"]),
+		subjectId: optionalText(row["subject_id"]),
+		summary: optionalText(row["summary"]),
+		data: isRecord(row["data"]) ? row["data"] : {},
+		occurredAt: toInstant(textOf(row["occurred_at"]))
+	};
+}
+/** Comments over the `comments` module's functions, as the caller. */
+function createComments(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const mentionsOf = (body, document) => options.mentionsOf ? options.mentionsOf({
+		body,
+		document
+	}) : mentionsIn(body);
+	return {
+		create: (comment) => call("create_comment", {
+			tenant: comment.organizationId,
+			subject_type: comment.subjectType,
+			subject_id: comment.subjectId,
+			body: comment.body,
+			mentions: comment.mentions ?? mentionsOf(comment.body, comment.document),
+			parent: comment.parentId,
+			document: comment.document
+		}, commentOf),
+		edit: (id, edit) => call("edit_comment", {
+			id,
+			body: edit.body,
+			mentions: edit.mentions ?? mentionsOf(edit.body, edit.document),
+			document: edit.document ?? void 0,
+			...edit.document === null ? { clear_document: true } : {}
+		}, (value) => value).andThen((value) => Promise.resolve(value === null || value === void 0 ? err(dbError("not_found", "No comment you can edit has this id", { hint: "COMMENT_NOT_FOUND" })) : ok(commentOf(value)))),
+		remove: (id) => call("delete_comment", { id }, (value) => value === true),
+		list: (organizationId, subjectType, subjectId, list = {}) => call("list_comments", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			after: instantArg(pageOf(list).cursor),
+			max_rows: list.limit,
+			skip: list.offset
+		}, (value) => recordsOf(value, "list_comments").map(commentOf)),
+		counts: (organizationId, subjectType, subjectIds) => call("comment_counts", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_ids: [...subjectIds]
+		}, (value) => {
+			const found = isRecord(value) ? value : {};
+			return Object.fromEntries(subjectIds.map((id) => [id, Number(found[id] ?? 0)]));
+		}),
+		copy: (organizationId, from, to) => call("copy_comments", {
+			tenant: organizationId,
+			from_type: from.type,
+			from_id: from.id,
+			to_type: to.type,
+			to_id: to.id
+		}, (value) => Number(value ?? 0)),
+		history: (organizationId, subject, history = {}) => call("list_activity", {
+			tenant: organizationId,
+			subject_type: subject?.type,
+			subject_id: subject?.id,
+			before: instantArg(pageOf(history).cursor),
+			max_rows: history.limit
+		}, (value) => recordsOf(value, "list_activity").map(activityOf))
+	};
+}
+const matches = (patterns, type) => patterns.some((pattern) => pattern.endsWith(".*") ? type.startsWith(pattern.slice(0, -1)) : pattern === type);
+const firstText = (data, keys) => {
+	for (const key of keys) {
+		const value = optionalText(data[key]);
+		if (value !== void 0) return value;
+	}
+};
+/** `comments/<id>` as `{ type: "comment", id }`, the shape block subjects use. */
+function subjectOf(subject) {
+	const slash = subject?.indexOf("/") ?? -1;
+	if (subject === void 0 || slash < 1) return void 0;
+	const plural = subject.slice(0, slash);
+	return {
+		type: plural.endsWith("s") ? plural.slice(0, -1) : plural,
+		id: subject.slice(slash + 1)
+	};
+}
+/**
+* An outbox sink that writes events into the activity feed:
+* `outbox.relay('activity', activitySink({ transport }))`. Events without a
+* tenant (`partitionkey`) are skipped, and a replayed event writes nothing.
+*/
+function activitySink(options) {
+	const schema = options.schema ?? "better_supabase";
+	const prefix = `${options.typePrefix ?? "dev.better-supabase"}.`;
+	return { async send(events) {
+		const entries = [];
+		for (const event of events) {
+			const tenant = optionalText(event["partitionkey"]);
+			if (tenant === void 0) continue;
+			const type = event.type.startsWith(prefix) ? event.type.slice(prefix.length) : event.type;
+			if (options.types && !matches(options.types, type)) continue;
+			const described = options.describe ? options.describe(event, type) : {};
+			if (described === null) continue;
+			const data = isRecord(event.data) ? event.data : {};
+			const subject = subjectOf(event.subject);
+			entries.push({
+				event_id: event.id,
+				organization_id: tenant,
+				type,
+				actor_id: described?.actorId ?? firstText(data, [
+					"actorId",
+					"authorId",
+					"userId"
+				]),
+				subject_type: described?.subjectType ?? optionalText(data["subjectType"]) ?? subject?.type,
+				subject_id: described?.subjectId ?? optionalText(data["subjectId"]) ?? subject?.id,
+				summary: described?.summary,
+				data: described?.data ?? data,
+				occurred_at: event.time
+			});
+		}
+		if (entries.length > 0) await options.transport.call(schema, "record_activity", { batch: { entries } });
+	} };
+}
+const FACETS = [
+	[
+		"type",
+		"type",
+		"type"
+	],
+	[
+		"actor",
+		"actor_id",
+		"actorId"
+	],
+	[
+		"subjectType",
+		"subject_type",
+		"subjectType"
+	],
+	[
+		"subjectId",
+		"subject_id",
+		"subjectId"
+	]
+];
+/**
+* A cursor-paged list over `activity_entries` (generate types for the
+* `better_supabase` schema to get it in your models), newest first,
+* filtered by type, actor and subject. Members with `activity.read` see
+* their tenants' entries.
+*/
+function activityListQuery(betterSupabase, table, options = {}) {
+	const meta = betterSupabase.meta.tables[table];
+	if (!meta) throw new TypeError(`activityListQuery: unknown table "${table}"`);
+	const camel = meta.columns["occurredAt"] !== void 0;
+	const facets = Object.fromEntries(FACETS.map(([key, snake, camelName]) => [key, camel ? camelName : snake]).filter(([, column]) => meta.columns[column] !== void 0));
+	const occurredAt = camel ? "occurredAt" : "occurred_at";
+	const config = {
+		facets,
+		sorts: {
+			newest: [{ [occurredAt]: "desc" }, { id: "desc" }],
+			oldest: [{ [occurredAt]: "asc" }, { id: "asc" }]
+		},
+		defaultSort: "newest",
+		pagination: "cursor",
+		...options.pageSize === void 0 ? {} : { pageSize: options.pageSize },
+		...options.maxPageSize === void 0 ? {} : { maxPageSize: options.maxPageSize }
+	};
+	return defineListQuery(betterSupabase, table, config);
+}
+//#endregion
+export { activityListQuery, activitySink, createComments, mentionsIn, rpcTransport, sqlTransport };

package/dist/blocks/connectors/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 ConnectorSession, c as ConnectorsOptions, i as ConnectorServerFields, l as FingerprintStatus, n as ConnectorGrant, o as ConnectorTransport, r as ConnectorServer, s as Connectors, t as ConnectorAuth, u as createConnectors } from "../../connectors-hkLCwyEz.js";
+export { type BlockTransport, type ConnectorAuth, type ConnectorGrant, type ConnectorServer, type ConnectorServerFields, type ConnectorSession, type ConnectorTransport, type Connectors, type ConnectorsOptions, type FingerprintStatus, createConnectors, rpcTransport, sqlTransport };

package/dist/blocks/connectors/index.js

@@ -0,0 +1,164 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as ok, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { D as stringsOf, O as textOf, a as credentialRefOf, d as isRecord, h as optionalText, i as blockCall, k as toInstant, m as optionalInstant, n as applyTemporal, u as instantArg, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { n as revokeIfConfigured } from "../../compose-BIBNgAnq.js";
+//#region src/blocks/connectors/connectors.ts
+const TRANSPORTS = /* @__PURE__ */ new Set(["http", "sse"]);
+const AUTHS = /* @__PURE__ */ new Set([
+	"none",
+	"oauth",
+	"header"
+]);
+const STATUSES = /* @__PURE__ */ new Set([
+	"approved",
+	"pending",
+	"rejected"
+]);
+const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
+function grantOf(value) {
+	const row = recordOf(value, "connector_grants");
+	const credentialRef = credentialRefOf(row["credential_ref"]);
+	if (credentialRef === void 0) throw new TypeError("connector_grants returned a grant without a ref");
+	return {
+		id: textOf(row["id"]),
+		userId: textOf(row["user_id"]),
+		serverId: textOf(row["server_id"]),
+		organizationId: textOf(row["organization_id"]),
+		credentialRef,
+		scopes: stringsOf(row["scopes"]),
+		expiresAt: optionalInstant(row["expires_at"]),
+		grantedAt: instant(row["granted_at"]),
+		revokedAt: optionalInstant(row["revoked_at"])
+	};
+}
+function serverOf(value) {
+	const row = recordOf(value, "connector_servers");
+	const transport = textOf(row["transport"]);
+	const authType = textOf(row["auth_type"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		name: textOf(row["name"]),
+		url: textOf(row["url"]),
+		transport: TRANSPORTS.has(transport) ? transport : "http",
+		authType: AUTHS.has(authType) ? authType : "none",
+		credentialRef: credentialRefOf(row["credential_ref"]),
+		scopes: stringsOf(row["scopes"]),
+		clientMetadata: isRecord(row["client_metadata"]) ? row["client_metadata"] : {},
+		enabled: row["enabled"] !== false,
+		grant: isRecord(row["grant"]) ? grantOf(row["grant"]) : void 0,
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(row["updated_at"])
+	};
+}
+function fieldsArg(fields) {
+	const out = {};
+	if (fields.name !== void 0) out["name"] = fields.name;
+	if (fields.url !== void 0) out["url"] = fields.url;
+	if (fields.transport !== void 0) out["transport"] = fields.transport;
+	if (fields.authType !== void 0) out["auth_type"] = fields.authType;
+	if (fields.credentialRef !== void 0) out["credential_ref"] = fields.credentialRef;
+	if (fields.scopes !== void 0) out["scopes"] = fields.scopes;
+	if (fields.clientMetadata !== void 0) out["client_metadata"] = fields.clientMetadata;
+	if (fields.enabled !== void 0) out["enabled"] = fields.enabled;
+	return out;
+}
+const notFound = () => dbError("not_found", "No connector you can see has this id", { hint: "CONNECTOR_NOT_FOUND" });
+/** MCP servers, per-user grants, sessions and tool list fingerprints. */
+function createConnectors(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const credentials = options.credentials;
+	const revokeCredential = (grant) => revokeIfConfigured(credentials, grant.credentialRef, { subject: {
+		type: "user",
+		id: grant.userId
+	} }).map(() => true);
+	const revokeAll = (grants) => AsyncResult.from(async () => {
+		for (const grant of grants) {
+			const revoked = await revokeCredential(grant);
+			if (!revoked.ok) return revoked;
+		}
+		return ok(grants.length);
+	});
+	const save = (organizationId, serverId, fields) => call("save_connector_server", {
+		tenant: organizationId,
+		id: serverId,
+		fields: fieldsArg(fields)
+	}, serverOf);
+	const decide = (serverId, fingerprint, approved) => call("decide_connector_fingerprint", {
+		server_id: serverId,
+		fingerprint,
+		approved
+	}, (value) => value === true);
+	return {
+		servers: {
+			list: (organizationId) => call("list_connector_servers", { tenant: organizationId }, (value) => recordsOf(value, "list_connector_servers").map(serverOf)),
+			get: (serverId, getOptions = {}) => (getOptions.ownerId === void 0 ? call : service)("get_connector", {
+				id: serverId,
+				owner: getOptions.ownerId
+			}, (value) => value).andThen((value) => isRecord(value) ? AsyncResult.ok(serverOf(value)) : AsyncResult.err(notFound())),
+			create: (organizationId, server) => save(organizationId, void 0, server),
+			update: (organizationId, serverId, fields) => save(organizationId, serverId, fields),
+			remove: (serverId) => call("delete_connector_server", { id: serverId }, (value) => recordsOf(value, "delete_connector_server").map(grantOf)).andThen(revokeAll)
+		},
+		grants: {
+			record: (serverId, userId, credentialRef, recordOptions = {}) => service("record_connector_grant", {
+				server_id: serverId,
+				owner: userId,
+				credential_ref: credentialRef,
+				scopes: recordOptions.scopes,
+				expires_at: instantArg(recordOptions.expiresAt)
+			}, (value) => recordOf(value, "record_connector_grant")).andThen((row) => {
+				const grant = grantOf(row["grant"]);
+				const replaced = isRecord(row["replaced"]) ? grantOf(row["replaced"]) : void 0;
+				return replaced !== void 0 && JSON.stringify(replaced.credentialRef) !== JSON.stringify(grant.credentialRef) ? revokeCredential(replaced).map(() => grant) : AsyncResult.ok(grant);
+			}),
+			revoke: (grantId) => call("revoke_connector_grant", { id: grantId }, (value) => value).andThen((value) => isRecord(value) ? revokeCredential(grantOf(value)) : AsyncResult.ok(false)),
+			expiring: (before, expiringOptions = {}) => service("expiring_connector_grants", {
+				before: before.toString(),
+				max_rows: expiringOptions.limit
+			}, (value) => recordsOf(value, "expiring_connector_grants").map(grantOf)),
+			renew: (grantId, expiresAt) => service("renew_connector_grant", {
+				id: grantId,
+				expires_at: expiresAt.toString()
+			}, (value) => value === true)
+		},
+		sessions: {
+			get: (serverId, chatKey) => call("get_connector_session", {
+				server_id: serverId,
+				chat_key: chatKey ?? ""
+			}, (value) => isRecord(value) ? {
+				sessionId: optionalText(value["session_id"]),
+				initializeResult: isRecord(value["initialize_result"]) ? value["initialize_result"] : void 0,
+				expiresAt: instant(value["expires_at"])
+			} : void 0),
+			save: (serverId, session) => call("save_connector_session", {
+				server_id: serverId,
+				chat_key: session.chatKey ?? "",
+				session_id: session.sessionId,
+				initialize_result: session.initializeResult
+			}, (value) => value === true),
+			forget: (serverId, chatKey) => call("save_connector_session", {
+				server_id: serverId,
+				chat_key: chatKey ?? ""
+			}, (value) => value === true),
+			purge: () => service("purge_connector_sessions", {}, Number)
+		},
+		fingerprints: {
+			check: (serverId, fingerprint, tools) => call("check_connector_fingerprint", {
+				server_id: serverId,
+				fingerprint,
+				tools
+			}, (value) => {
+				const status = textOf(value);
+				return STATUSES.has(status) ? status : "pending";
+			}),
+			approve: (serverId, fingerprint) => decide(serverId, fingerprint, true),
+			reject: (serverId, fingerprint) => decide(serverId, fingerprint, false)
+		}
+	};
+}
+//#endregion
+export { createConnectors, rpcTransport, sqlTransport };