better-supabase 0.8.0 → 0.9.0

package/dist/block-hooks-BsXncUlZ.js

@@ -0,0 +1,114 @@
+import { n as dbError, o as isDbError } from "./errors-8i6tSICm.js";
+import { r as err, t as AsyncResult } from "./result-BlgnMB0H.js";
+import { t as consoleLogger } from "./logger-glM28NVN.js";
+import { o as blockCall } from "./block-helpers-CfG_MvDR.js";
+//#region src/core/block-hooks.ts
+const isPlainObject = (value) => {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+/** A copy of plain objects and arrays; class instances (Temporal values) are immutable and stay shared. */
+function copyOf(value) {
+	if (Array.isArray(value)) return value.map(copyOf);
+	if (typeof value === "object" && value !== null && isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyOf(entry)]));
+	return value;
+}
+/** A new client with the same methods: a spread for object literals, a child object otherwise. */
+function cloneClient(client) {
+	if (isPlainObject(client)) return { ...client };
+	return Object.create(client);
+}
+/** The client's method named `name`, or undefined when it has none. */
+function methodOf(client, name) {
+	const value = client[name];
+	if (typeof value !== "function") return;
+	return value;
+}
+/**
+* Runs `hooks` around a block client's methods. Use it to add a rule the
+* block doesn't know (refuse `invite` above a seat limit), rewrite arguments
+* (fill a default), or observe results (metrics, an audit line). Methods
+* without hooks are unchanged.
+*
+* ```ts
+* const orgs = withBlockHooks(createOrganizations(options), {
+*   invite: { before: ([input]) => (input.role === "owner" ? dbError("forbidden", "Owners are added by support") : undefined) },
+* });
+* ```
+*/
+function withBlockHooks(client, hooks, options = {}) {
+	if (hooks === void 0) return client;
+	const block = options.block ?? "block";
+	const logger = options.logger ?? consoleLogger;
+	const wrapped = cloneClient(client);
+	for (const [method, hook] of Object.entries(hooks)) {
+		if (hook === void 0) continue;
+		const original = methodOf(client, method);
+		if (original === void 0) throw new TypeError(`better-supabase: ${block} has no method "${method}" to hook`);
+		const { before, after } = hook;
+		const info = {
+			block,
+			method
+		};
+		wrapped[method] = (...args) => AsyncResult.from(async () => {
+			let current = args;
+			if (before) {
+				const outcome = await before(current, info);
+				if (isDbError(outcome)) return err(outcome);
+				if (Array.isArray(outcome)) current = outcome;
+			}
+			const result = await original.apply(client, current);
+			if (after) try {
+				await after(copyOf(result), current, info);
+			} catch (cause) {
+				logger.error(`${block}.${method} after hook threw`, { cause });
+			}
+			return result;
+		});
+	}
+	return wrapped;
+}
+/**
+* Adds methods to a block client. The builder gets the base client, so a
+* new method can compose existing ones, and `call` for SQL functions the
+* app adds to the block's schema. Redefining a base method throws: wrap it
+* with `withBlockHooks` instead.
+*
+* ```ts
+* const orgs = extendBlock(createOrganizations(options), (base, { call }) => ({
+*   archive: (id: string) => call("archive_organization", { id }, () => undefined),
+* }), { transport: options.transport });
+* ```
+*/
+function extendBlock(client, build, options = {}) {
+	const { transport } = options;
+	const additions = build(client, { call: transport ? blockCall(transport, options.schema ?? "better_supabase", options.mappers ?? []) : () => AsyncResult.err(dbError("unsupported", "extendBlock needs the transport option to call SQL functions")) });
+	const taken = Object.keys(additions).filter((key) => key in client);
+	if (taken.length > 0) throw new TypeError(`better-supabase: extendBlock can't redefine ${taken.map((key) => `"${key}"`).join(", ")}; wrap a base method with withBlockHooks instead`);
+	return Object.assign(cloneClient(client), additions);
+}
+/** Fills in `apiVersion: 1`. */
+function defineTransportMiddleware(middleware) {
+	return {
+		...middleware,
+		apiVersion: 1
+	};
+}
+/**
+* A transport that runs `middleware` around `transport`, the first one
+* outermost. Throws when a middleware targets an API other than 1.
+*/
+function wrapTransport(transport, ...middleware) {
+	for (const entry of middleware) {
+		const version = entry.apiVersion;
+		if (version !== 1) throw new TypeError(`better-supabase: transport middleware "${entry.name}" targets API ${String(version)}; this better-supabase supports 1`);
+	}
+	const run = middleware.reduceRight((next, entry) => (request) => entry.call(request, next), (request) => transport.call(request.schema, request.fn, request.args));
+	return { call: (schema, fn, args) => run({
+		schema,
+		fn,
+		args
+	}) };
+}
+//#endregion
+export { wrapTransport as i, extendBlock as n, withBlockHooks as r, defineTransportMiddleware as t };

package/dist/block-transport-DaGGXjIw.d.ts

@@ -0,0 +1,70 @@
+import { r as Executor } from "./executor-DoE-5iM8.js";
+import { n as SqlClient } from "./executor-BBHgjUJu.js";
+//#region src/core/block-transport.d.ts
+/**
+ * Calls a block function as the current user and resolves with its result.
+ * Rejects with the raw database error (a `pg` error or a PostgREST error
+ * object), which the block maps to a `DbError`.
+ */
+interface BlockTransport {
+  call(schema: string, fn: string, args: Readonly<Record<string, unknown>>): Promise<unknown>;
+}
+/**
+ * Calls the functions over Postgres, as the user `client` runs as:
+ * `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
+ */
+declare function sqlTransport(client: SqlClient): BlockTransport;
+interface RpcResponse {
+  readonly data: unknown;
+  readonly error: unknown;
+}
+/**
+ * The part of a supabase-js client `rpcTransport` uses. The parameters are
+ * `never` so a typed `SupabaseClient<Database>` fits too: its `schema` and
+ * `rpc` only take the names its `Database` declares, which never include the
+ * block functions of a schema the types leave out.
+ */
+interface RpcClient {
+  schema(name: never): {
+    rpc(fn: never, args: never): PromiseLike<RpcResponse>;
+  };
+}
+/** Options for `rpcTransport`. */
+interface RpcTransportOptions {
+  /**
+   * The exposed schema that holds the block's entry points, such as `api`
+   * from `blocks.<module>.api`. Every call goes there instead of the
+   * module schema, which stays out of `[api] schemas` (doctor BS312).
+   */
+  readonly schema?: string;
+}
+/**
+ * Calls the functions over the Data API with the user's session. Pass
+ * `schema` with the API schema that `blocks.<module>.api` writes
+ * wrappers into; without it the calls go to the module schema, which then
+ * has to be exposed.
+ */
+declare function rpcTransport(client: RpcClient, options?: RpcTransportOptions): BlockTransport;
+/** Options for `dbTransport`. */
+interface DbTransportOptions {
+  /**
+   * The schema every call goes to instead of the module schema, such as the
+   * API schema from `blocks.<module>.api`. Over PostgREST it has to be
+   * exposed; over Postgres any schema the caller may use works.
+   */
+  readonly schema?: string;
+}
+/** The part of a `Db` that `dbTransport` uses. */
+interface DbTransportSource {
+  readonly $executor: Executor;
+}
+/**
+ * Calls the functions through a `Db`'s executor, so a block runs wherever
+ * the `Db` does: over PostgREST for `ctx.db` in a normal request, and over
+ * direct Postgres as the target in a support session or for an API key.
+ * Rejects with the raw database error, like the other transports, so the
+ * block's error mappers see the same codes and hints.
+ */
+declare function dbTransport(db: DbTransportSource, options?: DbTransportOptions): BlockTransport;
+//#endregion
+export { dbTransport as a, RpcClient as i, DbTransportOptions as n, rpcTransport as o, DbTransportSource as r, sqlTransport as s, BlockTransport as t };

package/dist/block-transport-G4t1umrR.js

@@ -0,0 +1,85 @@
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { i as sqlIdent } from "./template-DdgYjIZ5.js";
+//#region src/core/block-transport.ts
+/**
+* Calls the functions over Postgres, as the user `client` runs as:
+* `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
+*/
+function sqlTransport(client) {
+	return { async call(schema, fn, args) {
+		const entries = Object.entries(args).filter(([, value]) => value !== void 0);
+		const params = entries.map(([, value]) => value !== null && typeof value === "object" && (!Array.isArray(value) || value.some((entry) => entry !== null && typeof entry === "object")) ? JSON.stringify(value) : value);
+		const list = entries.map(([name], index) => `${sqlIdent(name)} => $${String(index + 1)}`).join(", ");
+		const [row] = await client.queryRaw(`select ${sqlIdent(schema)}.${sqlIdent(fn)}(${list}) as value`, params);
+		return row?.value ?? null;
+	} };
+}
+/**
+* Calls the functions over the Data API with the user's session. Pass
+* `schema` with the API schema that `blocks.<module>.api` writes
+* wrappers into; without it the calls go to the module schema, which then
+* has to be exposed.
+*/
+function rpcTransport(client, options = {}) {
+	const untyped = client;
+	return { async call(schema, fn, args) {
+		const defined = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0));
+		const { data, error } = await untyped.schema(options.schema ?? schema).rpc(fn, defined);
+		if (error) {
+			const message = typeof error === "object" && "message" in error ? String(error.message) : String(error);
+			throw Object.assign(new Error(message), error);
+		}
+		return data;
+	} };
+}
+/**
+* Calls the functions through a `Db`'s executor, so a block runs wherever
+* the `Db` does: over PostgREST for `ctx.db` in a normal request, and over
+* direct Postgres as the target in a support session or for an API key.
+* Rejects with the raw database error, like the other transports, so the
+* block's error mappers see the same codes and hints.
+*/
+function dbTransport(db, options = {}) {
+	return { async call(schema, fn, args) {
+		const executor = db.$executor;
+		if (!executor.rpc) throw new TypeError(`dbTransport needs an executor with rpc(); the ${executor.name} executor has none`);
+		let raw;
+		const capture = (error) => {
+			raw = error;
+		};
+		const defined = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0));
+		const result = await executor.rpc(fn, defined, {
+			schema: options.schema ?? schema,
+			errorMappers: [capture]
+		});
+		if (result.ok) return result.data;
+		if (raw === void 0) throw new DbException(result.error);
+		throw Object.assign(new Error(raw.message ?? result.error.message), raw);
+	} };
+}
+/** The Postgres or PostgREST error a transport rejected with, if it is one. */
+function rawError(cause) {
+	if (!isRecord(cause)) return;
+	const field = (key) => {
+		const value = cause[key];
+		return typeof value === "string" ? value : void 0;
+	};
+	if (field("code") === void 0) return;
+	const raw = {};
+	for (const key of [
+		"message",
+		"code",
+		"details",
+		"hint",
+		"constraint"
+	]) {
+		const value = field(key);
+		if (value !== void 0) raw[key] = value;
+	}
+	const detail = field("detail");
+	if (raw["details"] === void 0 && detail !== void 0) raw["details"] = detail;
+	return raw;
+}
+//#endregion
+export { sqlTransport as i, rawError as n, rpcTransport as r, dbTransport as t };

package/dist/blocks/access-requests/index.d.ts

@@ -0,0 +1,98 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { f as AccessRequestEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+//#region src/blocks/access-requests/access-requests.d.ts
+interface AccessRequestsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the request columns the app adds
+   * (`blocks.access-requests.options.extraColumns`), keyed by column name.
+   * It types and parses them on every read, and validates them on
+   * `request`, which returns a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AccessRequests<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * `pending`, `rejected`, `cancelled` and `expired` follow the approval
+ * request; `granted` and `ended` follow the role itself.
+ */
+type AccessRequestStatus = "pending" | "granted" | "rejected" | "cancelled" | "expired" | "ended";
+interface AccessRequest {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string;
+  readonly role: string;
+  /** The role the member held before the grant; unset for a new member. */
+  readonly previousRole?: string;
+  readonly reason?: string;
+  readonly duration?: Temporal.Duration;
+  readonly status: AccessRequestStatus;
+  /** The approvals request; approve, reject or cancel it there. */
+  readonly approvalId?: string;
+  readonly grantedAt?: Temporal.Instant;
+  /** When the grant ends; unset for a grant without a duration. */
+  readonly expiresAt?: Temporal.Instant;
+  readonly endedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+interface AccessRequestInput {
+  readonly organizationId: string;
+  readonly role: string;
+  readonly reason?: string;
+  /** How long the role lasts. Default: `options.maxDuration`, else no end. */
+  readonly duration?: Temporal.Duration;
+}
+interface AccessRequestListOptions {
+  /** Default: every status. */
+  readonly status?: AccessRequestStatus;
+  /** Only the caller's requests, even for readers of the organization. */
+  readonly mine?: boolean;
+  readonly pageSize?: number;
+  /** Requests made before this time, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+/** `F` is the extra fields `options.fields` describes. */
+interface AccessRequests<F extends object = Record<never, never>> {
+  /**
+   * Asks for a role; the approvals module routes it to the approvers. Keys
+   * besides the input's own are the request's extra columns.
+   */
+  request(input: AccessRequestInput & Partial<F>): AsyncResult<AccessRequest & F>;
+  /** Ends a granted role early: a manager, or the holder giving it up. */
+  end(id: string): AsyncResult<AccessRequest & F>;
+  get(id: string): AsyncResult<AccessRequest & F>;
+  /** Newest first. */
+  list(organizationId: string, options?: AccessRequestListOptions): AsyncResult<readonly (AccessRequest & F)[]>;
+}
+/** The `access-requests` SQL module as typed calls. */
+export declare function createAccessRequests<S extends StandardSchemaV1 | undefined = undefined>(options: AccessRequestsOptions<S>): AccessRequests<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/access-requests/events.d.ts
+/** The events of the `access-requests` block: type to data. */
+type AccessRequestsEvents = {
+  readonly "access.requested": AccessRequestEventData;
+  readonly "access.request_approved": AccessRequestEventData;
+  readonly "access.ended": AccessRequestEventData;
+};
+/** The `access-requests` block's event types, for its manifest and `onBlockEvent`. */
+export declare const accessRequestsEvents: Events<AccessRequestsEvents>;
+//#endregion
+//#region src/blocks/access-requests/manifest.d.ts
+/** The `access-requests` block's manifest (ADR 0029). */
+export declare const accessRequestsBlock: BlockOf<"access-requests", typeof createAccessRequests, AccessRequestsEvents>;
+//#endregion
+export { type AccessRequest, type AccessRequestInput, type AccessRequestListOptions, type AccessRequestStatus, type AccessRequests, type AccessRequestsEvents, type AccessRequestsOptions, type BlockTransport, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/access-requests/index.js

@@ -0,0 +1,99 @@
+import { t as temporal } from "../../temporal-required-DqRzr7i0.js";
+import { t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as accessRequestsSqlOptions } from "../../options-Ctac2R0Q.js";
+//#region src/blocks/access-requests/access-requests.ts
+const STATUSES = [
+	"pending",
+	"granted",
+	"rejected",
+	"cancelled",
+	"expired",
+	"ended"
+];
+function statusOf(value) {
+	const status = STATUSES.find((item) => item === value);
+	if (status === void 0) throw new TypeError(`unknown access request status ${String(value)}`);
+	return status;
+}
+const instant = (value, name) => value === null || value === void 0 ? {} : { [name]: requiredInstant(value, name) };
+function durationOf(value) {
+	const text = optionalText(value);
+	return text === void 0 ? {} : { duration: temporal().Duration.from(text) };
+}
+function requestOf(value, fn) {
+	const row = recordOf(value, fn);
+	const previousRole = optionalText(row["previousRole"]);
+	const reason = optionalText(row["reason"]);
+	const approvalId = optionalText(row["approvalId"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		userId: textOf(row["userId"]),
+		role: textOf(row["role"]),
+		status: statusOf(row["status"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...previousRole === void 0 ? {} : { previousRole },
+		...reason === void 0 ? {} : { reason },
+		...approvalId === void 0 ? {} : { approvalId },
+		...durationOf(row["duration"]),
+		...instant(row["grantedAt"], "grantedAt"),
+		...instant(row["expiresAt"], "expiresAt"),
+		...instant(row["endedAt"], "endedAt")
+	};
+}
+/** The `access-requests` SQL module as typed calls. */
+function createAccessRequests(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "access request fields");
+	const one = (fn, args) => call(fn, args, (value) => [value, requestOf(value, fn)]).andThen(([raw, row]) => withFields(fields, raw, row));
+	return withBlockHooks({
+		request: ({ organizationId, role, reason, duration, ...extra }) => AsyncResult.from(() => extraFieldsArg(fields, extra)).andThen((more) => one("request_access", {
+			tenant: organizationId,
+			role,
+			reason: reason ?? null,
+			duration: duration?.toString() ?? null,
+			...more
+		})),
+		end: (id) => one("end_access", { request_id: id }),
+		get: (id) => one("get_access_request", { request_id: id }),
+		list: (organizationId, list = {}) => call("list_access_requests", {
+			tenant: organizationId,
+			status: list.status ?? null,
+			mine: list.mine ?? false,
+			page_size: list.pageSize ?? null,
+			before: list.before?.toString() ?? null
+		}, (value) => recordsOf(value, "list_access_requests").map((raw) => [raw, requestOf(raw, "list_access_requests")])).andThen((rows) => allWithFields(fields, rows))
+	}, options.hooks, {
+		block: "access-requests",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/access-requests/events.ts
+/** The `access-requests` block's event types, for its manifest and `onBlockEvent`. */
+const accessRequestsEvents = defineEvents({
+	"access.requested": event(),
+	"access.request_approved": event(),
+	"access.ended": event()
+});
+//#endregion
+//#region src/blocks/access-requests/manifest.ts
+/** The `access-requests` block's manifest (ADR 0029). */
+const accessRequestsBlock = defineBlock({
+	name: "access-requests",
+	sql: ["access-requests"],
+	options: { "access-requests": accessRequestsSqlOptions },
+	events: accessRequestsEvents,
+	create: createAccessRequests,
+	category: "identity",
+	recipes: ["access-requests-inbox"]
+});
+//#endregion
+export { accessRequestsBlock, accessRequestsEvents, createAccessRequests, dbTransport, rpcTransport, sqlTransport };

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

@@ -1,3 +1,21 @@
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-inD4fFq-.js";
-import { a as AgentSkill, c as AgentsOptions, i as AgentKnowledgeScope, l as NewAgent, n as AgentFields, o as AgentVisibility, r as AgentFilter, s as Agents, t as Agent, u as createAgents } from "../../agents-BY_LQXtQ.js";
-export { type Agent, type AgentFields, type AgentFilter, type AgentKnowledgeScope, type AgentSkill, type AgentVisibility, type Agents, type AgentsOptions, type BlockTransport, type NewAgent, createAgents, dbTransport, rpcTransport, sqlTransport };
+import { p as AgentEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { a as AgentSkill, c as AgentsOptions, i as AgentKnowledgeScope, l as NewAgent, n as AgentFields, o as AgentVisibility, r as AgentFilter, s as Agents, t as Agent, u as createAgents } from "../../agents-BCNhIxVZ.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+//#region src/blocks/agents/events.d.ts
+/** The events of the `agents` block: type to data. */
+type AgentsEvents = {
+  readonly "agent.saved": AgentEventData;
+  readonly "agent.published": AgentEventData;
+  readonly "agent.deleted": AgentEventData;
+  readonly "agent.installed": AgentEventData;
+  readonly "agent.uninstalled": AgentEventData;
+};
+/** The `agents` block's event types, for its manifest and `onBlockEvent`. */
+export declare const agentsEvents: Events<AgentsEvents>;
+//#endregion
+//#region src/blocks/agents/manifest.d.ts
+/** The `agents` block's manifest (ADR 0029). */
+export declare const agentsBlock: BlockOf<"agents", typeof createAgents, AgentsEvents>;
+//#endregion
+export { type Agent, type AgentFields, type AgentFilter, type AgentKnowledgeScope, type AgentSkill, type AgentVisibility, type Agents, type AgentsEvents, type AgentsOptions, type BlockTransport, type NewAgent, createAgents, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/agents/index.js

@@ -1,7 +1,12 @@
-import { t as AsyncResult } from "../../result-DEqHCMKP.js";
+import { t as AsyncResult } from "../../result-BlgnMB0H.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-bAKh-dGc.js";
-import { A as stringsOf, N as toInstant, S as recordOf, _ as optionalInstant, i as blockCall, j as textOf, n as applyTemporal, p as notFoundError, v as optionalText, w as recordsOf } from "../../block-helpers-Cy3pB96I.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { C as optionalText, D as recordOf, F as stringsOf, I as textOf, S as optionalInstant, _ as notFoundError, h as instantOf, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { c as withFields, i as extraOf, n as blockFields, t as allWithFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as agentsSqlOptions } from "../../options-BxcFLL1G.js";
 //#region src/blocks/agents/agents.ts
 const VISIBILITIES = /* @__PURE__ */ new Set([
 	"private",
@@ -12,7 +17,6 @@ const visibilityOf = (value) => {
 	const text = textOf(value);
 	return VISIBILITIES.has(text) ? text : "private";
 };
-const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
 function scopesOf(value) {
 	if (!Array.isArray(value)) return [];
 	return value.filter(isRecord).map((item) => {
@@ -57,11 +61,22 @@ function agentOf(value) {
 		installed: row["installed"] === true,
 		myRating: rating === null || rating === void 0 ? void 0 : Number(rating),
 		skills: skillsOf(row["skills"]),
-		createdAt: instant(row["created_at"]),
-		updatedAt: instant(row["updated_at"])
+		createdAt: instantOf(row["created_at"]),
+		updatedAt: instantOf(row["updated_at"])
 	};
 }
 const notFound = () => notFoundError("No agent you can see has this id", "AGENT_NOT_FOUND");
+const AGENT_FIELDS = /* @__PURE__ */ new Set([
+	"slug",
+	"name",
+	"description",
+	"instructions",
+	"model",
+	"tools",
+	"connectorIds",
+	"knowledgeScopes",
+	"starters"
+]);
 function fieldsArg(fields) {
 	const out = {};
 	if (fields.slug !== void 0) out["slug"] = fields.slug;
@@ -79,13 +94,19 @@ function fieldsArg(fields) {
 function createAgents(options) {
 	applyTemporal(options);
 	const call = blockCall(options.transport, options.schema, options.mappers);
-	const found = (value) => isRecord(value) ? AsyncResult.ok(agentOf(value)) : AsyncResult.err(notFound());
-	const save = (organizationId, agentId, fields) => call("save_agent", {
+	const fields = blockFields(options.fields, "agent fields");
+	const typed = (value) => AsyncResult.from(() => withFields(fields, value, agentOf(value)));
+	const one = (fn, args) => call(fn, args, (value) => value).andThen(typed);
+	const found = (value) => isRecord(value) ? typed(value) : AsyncResult.err(notFound());
+	const save = (organizationId, agentId, agent) => AsyncResult.from(() => fields.write(extraOf(agent, AGENT_FIELDS))).andThen((extra) => one("save_agent", {
 		tenant: organizationId,
 		id: agentId,
-		fields: fieldsArg(fields)
-	}, agentOf);
-	return {
+		fields: {
+			...extra,
+			...fieldsArg(agent)
+		}
+	}));
+	return withBlockHooks({
 		create: (organizationId, agent) => save(organizationId, void 0, agent),
 		update: (organizationId, agentId, fields) => save(organizationId, agentId, fields),
 		get: (agentId) => call("get_agent", { id: agentId }, (value) => value).andThen(found),
@@ -98,27 +119,52 @@ function createAgents(options) {
 			filter: listOptions.filter,
 			search: listOptions.search,
 			max_rows: listOptions.limit
-		}, (value) => recordsOf(value, "list_agents").map(agentOf)),
-		publish: (agentId, visibility) => call("publish_agent", {
+		}, (value) => recordsOf(value, "list_agents").map((raw) => [raw, agentOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+		publish: (agentId, visibility) => one("publish_agent", {
 			id: agentId,
 			visibility
-		}, agentOf),
+		}),
 		install: (organizationId, agentId, installed = true) => call("install_agent", {
 			tenant: organizationId,
 			agent_id: agentId,
 			installed
 		}, (value) => value === true),
-		rate: (agentId, rating, comment) => call("rate_agent", {
+		rate: (agentId, rating, comment) => one("rate_agent", {
 			agent_id: agentId,
 			rating,
 			comment
-		}, agentOf),
+		}),
 		setSkills: (agentId, skills) => call("set_agent_skills", {
 			agent_id: agentId,
 			skills: { items: skills }
 		}, Number),
 		remove: (agentId) => call("delete_agent", { id: agentId }, (value) => value === true)
-	};
+	}, options.hooks, {
+		block: "agents",
+		...options.logger ? { logger: options.logger } : {}
+	});
 }
 //#endregion
-export { createAgents, dbTransport, rpcTransport, sqlTransport };
+//#region src/blocks/agents/events.ts
+/** The `agents` block's event types, for its manifest and `onBlockEvent`. */
+const agentsEvents = defineEvents({
+	"agent.saved": event(),
+	"agent.published": event(),
+	"agent.deleted": event(),
+	"agent.installed": event(),
+	"agent.uninstalled": event()
+});
+//#endregion
+//#region src/blocks/agents/manifest.ts
+/** The `agents` block's manifest (ADR 0029). */
+const agentsBlock = defineBlock({
+	name: "agents",
+	sql: ["agents"],
+	options: { agents: agentsSqlOptions },
+	events: agentsEvents,
+	create: createAgents,
+	category: "ai",
+	recipes: ["agent-run-trace"]
+});
+//#endregion
+export { agentsBlock, agentsEvents, createAgents, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/ai-cache/index.d.ts

@@ -1,3 +1,8 @@
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-inD4fFq-.js";
-import { a as AiCacheSetOptions, i as AiCacheOptions, n as AiCacheEntry, o as cacheKey, r as AiCacheKind, s as createAiCache, t as AiCache } from "../../ai-cache-DrUMMgp6.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { a as AiCacheSetOptions, i as AiCacheOptions, n as AiCacheEntry, o as cacheKey, r as AiCacheKind, s as createAiCache, t as AiCache } from "../../ai-cache-Dps7aRu1.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+//#region src/blocks/ai-cache/manifest.d.ts
+/** The `ai-cache` block's manifest (ADR 0029). */
+export declare const aiCacheBlock: BlockOf<"ai-cache", typeof createAiCache>;
+//#endregion
 export { type AiCache, type AiCacheEntry, type AiCacheKind, type AiCacheOptions, type AiCacheSetOptions, type BlockTransport, cacheKey, createAiCache, dbTransport, rpcTransport, sqlTransport };

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

@@ -1,3 +1,15 @@
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-bAKh-dGc.js";
-import { n as createAiCache, t as cacheKey } from "../../ai-cache-Dfgk8nBT.js";
-export { cacheKey, createAiCache, dbTransport, rpcTransport, sqlTransport };
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { n as createAiCache, t as cacheKey } from "../../ai-cache-zeUL94pB.js";
+import { t as aiCacheSqlOptions } from "../../options-BlOPivzq.js";
+//#region src/blocks/ai-cache/manifest.ts
+/** The `ai-cache` block's manifest (ADR 0029). */
+const aiCacheBlock = defineBlock({
+	name: "ai-cache",
+	sql: ["ai-cache"],
+	options: { "ai-cache": aiCacheSqlOptions },
+	create: createAiCache,
+	category: "ai"
+});
+//#endregion
+export { aiCacheBlock, cacheKey, createAiCache, dbTransport, rpcTransport, sqlTransport };