better-supabase 0.14.0 → 0.15.0

package/dist/options-KV84gAxl.js

@@ -0,0 +1,10 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/activities/options.ts
+const activitiesSqlOptions = blockOptions({
+	types: option.strings(),
+	extraColumns: option.unknown(),
+	recordings: option.boolean({ default: false }),
+	bookings: option.boolean()
+});
+//#endregion
+export { activitiesSqlOptions as t };

package/dist/options-Li1Dyu88.d.ts

@@ -0,0 +1,10 @@
+import { t as BlockOptionsSchema } from "./options-CsGl5BLH.js";
+//#region src/blocks/courses/options.d.ts
+/** `blocks.courses.options`. */
+type CoursesSqlOptions = {
+  /** Extra columns on the courses table: column name to SQL type. */
+  readonly extraColumns?: unknown;
+};
+declare const coursesSqlOptions: BlockOptionsSchema<CoursesSqlOptions>;
+//#endregion
+export { coursesSqlOptions as n, CoursesSqlOptions as t };

package/dist/options-Q1Bzgqpr.js

@@ -0,0 +1,5 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/tags/options.ts
+const tagsSqlOptions = blockOptions({ extraColumns: option.unknown() });
+//#endregion
+export { tagsSqlOptions as t };

package/dist/options-_F-enoBs.d.ts

@@ -0,0 +1,26 @@
+import { t as BlockOptionsSchema } from "./options-CsGl5BLH.js";
+//#region src/blocks/content/options.d.ts
+/** `blocks.content.options`. */
+type ContentSqlOptions = {
+  /** The entry types, such as `page` and `post`. Default `["page", "post"]`. */
+  readonly types?: readonly string[];
+  /**
+   * The locales entries are written in; the first is the default. Default
+   * `["en"]`.
+   */
+  readonly locales?: readonly string[];
+  /**
+   * Publishing and scheduling by a writer open an approvals request, and the
+   * entry goes live once it is approved. Needs the approvals block. Default
+   * false.
+   */
+  readonly requireApproval?: boolean;
+  /**
+   * The approvals policy a publish request follows. Default: one approval by
+   * another member with `content.publish`.
+   */
+  readonly publishPolicy?: unknown;
+};
+declare const contentSqlOptions: BlockOptionsSchema<ContentSqlOptions>;
+//#endregion
+export { contentSqlOptions as n, ContentSqlOptions as t };

package/dist/options-c5WCsky5.js

@@ -0,0 +1,21 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/ai-chat/options.ts
+const aiChatSqlOptions = blockOptions({
+	topic: option.string({
+		default: "ai-chat",
+		client: true
+	}),
+	listTopic: option.string({
+		default: "ai-chats",
+		client: true
+	}),
+	temporaryTtl: option.unknown(),
+	staleAfter: option.unknown(),
+	sandboxIdleAfter: option.number({ default: 600 }),
+	meterUsage: option.boolean({ default: true }),
+	inputMeter: option.string({ default: "ai.input_tokens" }),
+	outputMeter: option.string({ default: "ai.output_tokens" }),
+	extraColumns: option.unknown()
+});
+//#endregion
+export { aiChatSqlOptions as t };

package/dist/options-nFzfgtA6.js

@@ -0,0 +1,5 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/ai-keys/options.ts
+const aiKeysSqlOptions = blockOptions({ pollEvery: option.number({ default: 60 }) });
+//#endregion
+export { aiKeysSqlOptions as t };

package/dist/options-pOVWwbAK.d.ts

@@ -0,0 +1,10 @@
+import { t as BlockOptionsSchema } from "./options-CsGl5BLH.js";
+//#region src/blocks/segments/options.d.ts
+/** `blocks.segments.options`. */
+type SegmentsSqlOptions = {
+  /** At most this many records in one segment. Default: 10000. */
+  readonly maxMembers?: number;
+};
+declare const segmentsSqlOptions: BlockOptionsSchema<SegmentsSqlOptions>;
+//#endregion
+export { segmentsSqlOptions as n, SegmentsSqlOptions as t };

package/dist/options-y_-AkVCs.d.ts

@@ -0,0 +1,15 @@
+import { t as BlockOptionsSchema } from "./options-CsGl5BLH.js";
+//#region src/blocks/sequences/options.d.ts
+/** `blocks.sequences.options`. */
+type SequencesSqlOptions = {
+  /** Send attempts of an email step before the run exits as failed. Default 3. */
+  readonly maxAttempts?: number;
+  /**
+   * Minutes before a failed email step runs again, times the attempts so far.
+   * Default 15.
+   */
+  readonly retryMinutes?: number;
+};
+declare const sequencesSqlOptions: BlockOptionsSchema<SequencesSqlOptions>;
+//#endregion
+export { sequencesSqlOptions as n, SequencesSqlOptions as t };

package/dist/orpc/index.d.ts

@@ -1,18 +1,55 @@
-import { b as DbError, f as Result } from "../result-C6jDfedy.js";
-import { M as AnyFunctions, N as AnyModels } from "../executor-CPyrQdjh.js";
-import { r as AuthState } from "../resolve-CzUKTIMq.js";
-import { i as ProblemDetails } from "../problem-DpHB7tWl.js";
-import { c as RouteSpec } from "../options-Dm-2crCx.js";
-import { t as BetterSupabase } from "../define-Dw7pRO4h.js";
-import { a as ServerContext, c as ServerOptions, n as BetterServer } from "../server-types-BOs-eFpo.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-CZYibxUx.js";
-import { c as ResourceLoaderContext, i as AuthorizeOptions } from "../kit-DKfbNTAA.js";
+import { b as DbError, f as Result } from "../result-DZeA5KS6.js";
+import { O as AnyFunctions, k as AnyModels } from "../types-DFdg_4yN.js";
+import { r as AuthState } from "../resolve-CXX6DHv3.js";
+import { i as ProblemDetails } from "../problem-DNwN8iGz.js";
+import { t as BetterSupabase } from "../define-DFBnQyYg.js";
+import { a as ServerContext, c as ServerOptions, n as BetterServer } from "../server-types-CFtehAsr.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-Dn1_YhC1.js";
+import { c as ResourceLoaderContext, i as AuthorizeOptions } from "../kit-DOwKpSkA.js";
 import { t as Validated } from "../shared-CRRfQAKG.js";
-import { i as RouteRateLimitRule, n as RateLimitVerdict, r as RateLimiter, t as RateLimitRouteOptions } from "../rate-limit-CrOuXfjj.js";
-import { i as BlockMethodName, n as BlockDataOf, r as BlockInputOf } from "../block-method-hsPAGFi5.js";
+import { a as ResourceHandler } from "../resource-types-DnKiH4G2.js";
+import { i as RouteRateLimitRule, n as RateLimitVerdict, r as RateLimiter, t as RateLimitRouteOptions } from "../rate-limit-Bztf32cl.js";
+import { t as Api } from "../api-DxAPqMrE.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { AnySchema, BuilderWithMiddlewares, DecoratedMiddleware, DecoratedProcedure, MetaPlugin, ORPCError, Schema } from "@orpc/server";
-import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/orpc/router.d.ts
+/** The route `router()` gives one operation of the API model. */
+interface ApiRoute {
+  readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  readonly path: `/${string}`;
+  readonly operationId: string;
+  readonly tags: string[];
+  readonly summary?: string;
+  readonly successStatus: number;
+  /**
+   * `detailed` for table operations (`{ params, query, body }`), `compact` for
+   * verbs (the body).
+   */
+  readonly inputStructure: "compact" | "detailed";
+}
+/** Options of `router()`. */
+interface ApiRouterOptions<G> {
+  /** Guard and authorize options every procedure runs behind. */
+  readonly guard?: G;
+  /**
+   * Route metadata per procedure: pass `openapi` from `@orpc/openapi`, so
+   * `OpenAPIHandler` serves each operation at its documented path.
+   */
+  readonly meta?: (route: ApiRoute) => MetaPlugin<AnySchema, AnySchema, Record<never, never>>;
+  /**
+   * Handlers for tables whose hooks or actions `defineApi` can't run from a
+   * description, such as `defineResource(betterSupabase, "customers", { hooks
+   * })`. A handler passed as the resource in `defineApi` is used as is.
+   */
+  readonly resources?: Readonly<Record<string, ResourceHandler<unknown>>>;
+}
+/** What `router()` returns: one procedure per operation, and their routes. */
+interface ApiRouter<P> {
+  /** One procedure per operation id, to mount in `os.router()`. */
+  readonly procedures: Readonly<Record<string, P>>;
+  readonly routes: readonly ApiRoute[];
+}
+//#endregion
 //#region src/bridges/orpc.d.ts
 /**
  * The part of an oRPC fetch handler (`RPCHandler`, `OpenAPIHandler`) a bridge
@@ -57,7 +94,7 @@ export interface OrpcRequestContext {
 }
 /** What `middleware()` adds to `context`. */
 export interface OrpcContext<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> {
-  readonly bs: ServerContext<M, F, E, C, P, B>;
+  readonly bsb: ServerContext<M, F, E, C, P, B>;
   readonly db: ServerContext<M, F, E, C, P, B>["db"];
   readonly auth: AuthState<C, P>;
 }
@@ -97,55 +134,20 @@ export interface OrpcRateLimitInput<TContext extends OrpcRequestContext> {
 export type OrpcRateLimitMiddleware<TContext extends OrpcRequestContext> = DecoratedMiddleware<TContext, Record<never, never>, unknown, any, Record<never, never>>;
 /** Guard and authorize options of `middleware()` and `authed()`. */
 export interface OrpcGuardOptions<C = unknown, P = unknown, X = ResourceLoaderContext<C, P>> extends MiddlewareOptions, AuthorizeOptions<unknown, C, P, boolean, unknown, X> {}
-/** `os` with the caller's context: `bs.authed().handler(({ context }) => ...)`. */
+/** `os` with the caller's context: `bsb.authed().handler(({ context }) => ...)`. */
 export type OrpcAuthed<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = BuilderWithMiddlewares<OrpcRequestContext, OrpcContext<M, F, E, C, P, B>, Record<never, never>>;
 /** The Workers execution context, typed structurally. */
 export interface OrpcExecutionContext {
   waitUntil(promise: Promise<unknown>): void;
 }
-/** The HTTP route `blockRouter` gives one block method. */
-export interface BlockRoute {
-  readonly method: "POST";
-  readonly path: `/${string}`;
-  readonly operationId: string;
-}
-/** Options of `blockRouter()`. */
-export interface BlockRouterOptions<Cl, K extends BlockMethodName<Cl>, G = OrpcGuardOptions> {
-  /** The path segment and operation id prefix, such as `invoices`. */
-  readonly name: string;
-  /** The methods to expose; the client is only built per request. */
-  readonly methods: readonly K[];
-  /**
-   * Input schemas by method, such as the generated block input schemas. They
-   * aren't typed against the method: a type that names the client fixes it
-   * before a `client` callback that destructures its context is inferred.
-   */
-  readonly schemas?: { readonly [Name in K]?: StandardSchemaV1; };
-  /** Guard and authorize options every procedure runs behind. */
-  readonly guard?: G;
-  /** Tags for the documented routes. */
-  readonly tags?: readonly string[];
-  /**
-   * Route metadata per procedure, such as `openapi` from `@orpc/openapi`, so
-   * `OpenAPIHandler` serves each method at its documented route.
-   */
-  readonly meta?: (route: BlockRoute) => MetaPlugin<AnySchema, AnySchema, Record<never, never>>;
-}
-/** One block method as an oRPC procedure, typed by its input and data. */
-export type BlockProcedure<M extends AnyModels, F extends AnyFunctions, E, C, P, B, I, O> = DecoratedProcedure<OrpcRequestContext, OrpcContext<M, F, E, C, P, B>, Schema<I, I>, Schema<O, O>, Record<never, never>>;
-/** What `blockRouter()` returns: the procedures and their documented routes. */
-export interface BlockRouter<M extends AnyModels, F extends AnyFunctions, E, C, P, B, Cl, K extends BlockMethodName<Cl>> {
-  /** One procedure per method, to mount in `os.router()`. */
-  readonly procedures: { readonly [Name in K]: BlockProcedure<M, F, E, C, P, B, BlockInputOf<Cl, Name>, BlockDataOf<Cl, Name>>; };
-  /** The routes for `buildApiModel({ routes })`, one `POST` per method. */
-  readonly routes: readonly RouteSpec[];
-}
+/** One API operation as an oRPC procedure. */
+export type ApiProcedure<M extends AnyModels, F extends AnyFunctions, E, C, P, B> = DecoratedProcedure<OrpcRequestContext, OrpcContext<M, F, E, C, P, B>, Schema<unknown, unknown>, Schema<unknown, unknown>, Record<never, never>>;
 export interface BetterOrpc<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> extends BetterServer<M, F, E, C, P, B> {
   /**
    * Resolves the caller, enforces `allow` and adds `context.db`, `context.auth`
-   * and `context.bs`. Thrown `DbException`s, and errors caused by a `DbError`,
+   * and `context.bsb`. Thrown `DbException`s, and errors caused by a `DbError`,
    * become `ORPCError`s. Serve the router with `fetchHandler` so refreshed
-   * session cookies and `bs-primary-until` reach the response.
+   * session cookies and `bsb-primary-until` reach the response.
    */
   middleware(options?: OrpcGuardOptions<C, P, ServerContext<M, F, E, C, P, B> & ResourceLoaderContext<C, P>>): OrpcMiddleware<M, F, E, C, P, B>;
   /**
@@ -153,11 +155,9 @@ export interface BetterOrpc<M extends AnyModels, F extends AnyFunctions, E, C =
    * from the caller's context instead of repeating `.use()`:
    *
    * ```ts
-   * export const list = bs
-   *   .authed({ requireTenant: true })
-   *   .handler(({ context }) =>
-   *     bs.unwrap(context.db.customers.findMany()),
-   *   );
+   * export const list = bsb
+   *   .authed({ requireOrganization: true })
+   *   .handler(({ context }) => bsb.unwrap(context.db.customers.list()));
    * ```
    */
   authed(options?: OrpcGuardOptions<C, P, ServerContext<M, F, E, C, P, B> & ResourceLoaderContext<C, P>>): OrpcAuthed<M, F, E, C, P, B>;
@@ -183,27 +183,25 @@ export interface BetterOrpc<M extends AnyModels, F extends AnyFunctions, E, C =
   unwrap<T>(value: T | PromiseLike<T>): Promise<T>;
   toOrpcError(error: DbError): ORPCError<string, ProblemDetails>;
   /**
-   * Exposes a block's client methods as procedures behind `middleware()`. A
-   * method that takes more than one argument takes them as a tuple:
+   * Serves the API model as oRPC procedures behind `middleware()`, one per
+   * operation: every table's REST operations and verbs, through
+   * `defineResource`, and every block instance's verbs, through its client on
+   * `context.db`. A verb that takes more than one argument takes them as a JSON
+   * array.
    *
    * ```ts
-   * const invoices = bs.blockRouter(
-   *   ({ supabase }) => blocks(supabase).invoices,
-   *   {
-   *     name: "invoices",
-   *     methods: ["create", "issue"],
-   *     schemas: invoiceInputSchemas,
-   *     meta: openapi,
-   *   },
+   * const api = defineApi(betterSupabase, { info, basePath: "/api" });
+   * const { procedures } = bsb.router(api, { meta: openapi });
+   * export const handler = bsb.fetchHandler(
+   *   new OpenAPIHandler(os.router(procedures)),
    * );
-   * export const router = os.router({ invoices: invoices.procedures });
    * ```
    */
-  blockRouter<Cl extends object, const K extends string>(client: (ctx: ServerContext<M, F, E, C, P, B>) => Cl, options: BlockRouterOptions<Cl, K & BlockMethodName<Cl>, OrpcGuardOptions<C, P, ServerContext<M, F, E, C, P, B> & ResourceLoaderContext<C, P>>>): BlockRouter<M, F, E, C, P, B, Cl, K & BlockMethodName<Cl>>;
+  router(api: Api, options?: ApiRouterOptions<OrpcGuardOptions<C, P, ServerContext<M, F, E, C, P, B> & ResourceLoaderContext<C, P>>>): ApiRouter<ApiProcedure<M, F, E, C, P, B>>;
 }
 /** ORPC code for a `DbError`, from its HTTP status. */
 export declare function orpcCode(error: DbError): string;
 /** ORPC integration: middleware adding the caller's repositories to `context`. */
 export declare function createOrpc<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P, B>, options?: OrpcOptions): BetterOrpc<M, F, E, C, P, B>;
 //#endregion
-export type { GuardOptions, MiddlewareOptions, OrpcHandlerLike, RateLimitRouteOptions, RateLimitVerdict, RateLimiter, RouteRateLimitRule, ToOrpcOptions };
+export type { ApiRoute, ApiRouter, ApiRouterOptions, GuardOptions, MiddlewareOptions, OrpcHandlerLike, RateLimitRouteOptions, RateLimitVerdict, RateLimiter, RouteRateLimitRule, ToOrpcOptions };

package/dist/orpc/index.js

@@ -1,15 +1,157 @@
-import { r as dbErrorOf } from "../errors-03ysrOt4.js";
-import { c as toProblem } from "../problem-BWElIgIb.js";
+import { n as dbError, r as dbErrorOf } from "../errors-BVFgt8BZ.js";
+import { n as isRecord } from "../guards-6F2bCtQR.js";
+import { r as err } from "../result-ntFBW2p2.js";
+import { n as instanceProperty } from "../db-blocks-DJGbjIPz.js";
+import { c as toProblem } from "../problem-Bf0cJ7tk.js";
 import { i as claimsOf } from "../claims-Bp9My7XP.js";
-import { t as callWithInput } from "../block-method-Bvsao626.js";
-import { t as tenantOf } from "../tenant-DnMqeNIM.js";
-import { c as extendServer, n as flushEvents, s as createServer, x as refreshFor } from "../adapter-BCFAg58A.js";
-import { n as toSession } from "../view-BtgqxQLM.js";
-import { o as settle, r as guard, t as defaultExpose } from "../respond-z_yfyitp.js";
-import { t as authorizeCaller } from "../kit-Ct4Z6GIO.js";
-import { t as rateLimitGate } from "../rate-limit-B_U12PdL.js";
+import { t as callWithInput } from "../block-method-C9hWdHom.js";
+import { t as tenantOf } from "../tenant-BgIiMQpo.js";
+import { c as extendServer, n as flushEvents, s as createServer, x as refreshFor } from "../adapter-B0b6MXYS.js";
+import { r as checkPermission } from "../authorizer-BGhXaDmo.js";
+import { n as toSession } from "../view-C8Ve14ja.js";
+import { o as settle, r as guard, t as defaultExpose } from "../respond-C3CcOZlA.js";
+import { t as TABLE_VERBS } from "../resource-DvgXqZB_.js";
+import { r as contextOf, t as defineResource } from "../resource-DV2GC2dB.js";
+import { t as authorizeCaller } from "../kit-5l-o8RxL.js";
+import { t as rateLimitGate } from "../rate-limit-BWKGlhTM.js";
 import { bufferRequest, pipeline, seedContext } from "@supabase/middleware";
 import { COMMON_ERROR_STATUS_MAP, ORPCError, os } from "@orpc/server";
+//#region src/orpc/router.ts
+const METHODS = {
+	get: "GET",
+	post: "POST",
+	put: "PUT",
+	patch: "PATCH",
+	delete: "DELETE"
+};
+function isHandler(input) {
+	return isRecord(input) && typeof input["execute"] === "function" && typeof input["verb"] === "function";
+}
+function detailed(input) {
+	return isRecord(input) ? input : {};
+}
+/**
+* Whether `defineResource` can serve a description as it is: a list query with
+* its runner, validators and action handlers. A plain description from a
+* spec-only setup is not.
+*/
+function servable(table, input) {
+	if (input === true || "plan" in input) return;
+	if (input.list && !("parse" in input.list)) throw new TypeError(`${table}: the list query has no runner; pass the defineListQuery() result, or a handler in router({ resources })`);
+	for (const [name, action] of Object.entries(input.actions ?? {})) if (!("handler" in action)) throw new TypeError(`${table}.actions.${name} has no handler; pass a defineResource() handler in router({ resources })`);
+}
+function handlerFor(betterSupabase, authorizer, table, input) {
+	if (isHandler(input)) return input;
+	if (input !== true && "plan" in input) throw new TypeError(`${table}: the resource carries a plan but no handler; pass the defineResource() handler`);
+	servable(table, input);
+	return defineResource(betterSupabase, table, input === true ? {} : input, authorizer);
+}
+function successOf(operation) {
+	const status = Object.keys(operation.responses).find((key) => /^2\d\d$/u.test(key));
+	return status === void 0 ? 200 : Number(status);
+}
+function idOf(handler, input) {
+	return handler.keyParam === void 0 ? void 0 : input.params?.[handler.keyParam];
+}
+function tableRun(handler, operation) {
+	const { source } = operation;
+	switch (source.kind) {
+		case "resource": {
+			const name = source.operation;
+			return ({ input, db, request }) => {
+				const parts = detailed(input);
+				return handler.execute(db, name, {
+					id: idOf(handler, parts),
+					data: parts.body,
+					...parts.query ? { query: parts.query } : {},
+					request
+				});
+			};
+		}
+		case "action": {
+			const name = source.action;
+			return ({ input, db, request }) => {
+				const parts = detailed(input);
+				return handler.action(db, name, {
+					id: idOf(handler, parts),
+					data: parts.body,
+					...parts.query ? { query: parts.query } : {},
+					request
+				});
+			};
+		}
+		case "verb": {
+			const verb = TABLE_VERBS.find((each) => each === source.verb);
+			if (verb === void 0) throw new TypeError(`${handler.table}: unknown verb ${source.verb}`);
+			return ({ input, db, request }) => handler.verb(db, verb, {
+				data: input,
+				request
+			});
+		}
+		case "data-api":
+		case "route":
+		case "fragment": throw new TypeError(`${operation.id} is not a table operation of ${handler.table}`);
+		default: throw new TypeError(`Unknown operation source ${String(source)}`);
+	}
+}
+function blockRun(api, authorizer, operation) {
+	const { source } = operation;
+	if (source.kind !== "verb" || source.owner !== "block") throw new TypeError(`${operation.id} is not a block verb`);
+	const property = instanceProperty(source.name);
+	const name = source.member === void 0 ? source.verb : `${source.member}.${source.verb}`;
+	const permission = api.blocks[source.name]?.permissions?.[name];
+	return async ({ input, db }) => {
+		if (permission !== void 0) {
+			const permitted = await checkPermission({
+				authorizer,
+				permission,
+				resource: { type: source.name },
+				context: contextOf(db)
+			});
+			if (!permitted.ok) return permitted;
+		}
+		const blocks = "$blocks" in db ? db.$blocks : void 0;
+		const instance = isRecord(blocks) ? blocks[property] : void 0;
+		const client = source.member === void 0 || !isRecord(instance) ? instance : instance[source.member];
+		if (!isRecord(client)) return err(dbError("not_found", `The db has no ${source.name} block instance`));
+		return callWithInput(client, source.verb, input);
+	};
+}
+/**
+* The route and runner of every operation of the API model that has a server
+* here: table operations run through `defineResource`, verbs through the
+* repository or the block instance's client on the caller's Db. Custom routes
+* and the Data API stay with whoever serves them.
+*/
+function apiProcedures(betterSupabase, authorizer, api, resources = {}) {
+	const handlers = /* @__PURE__ */ new Map();
+	for (const [table, input] of Object.entries(api.resources)) handlers.set(table, resources[table] ?? handlerFor(betterSupabase, authorizer, table, input));
+	return api.model.operations.flatMap((operation) => {
+		const { source } = operation;
+		let run;
+		if (source.kind === "verb" && source.owner === "block") run = blockRun(api, authorizer, operation);
+		else if (source.kind === "resource" || source.kind === "action" || source.kind === "verb") {
+			const handler = handlers.get(source.kind === "verb" ? source.name : source.table);
+			if (!handler) return [];
+			run = tableRun(handler, operation);
+		} else return [];
+		const method = Object.entries(METHODS).find(([name]) => name === operation.method)?.[1];
+		if (method === void 0 || !operation.path.startsWith("/")) return [];
+		return [{
+			route: {
+				method,
+				path: `/${operation.path.slice(1)}`,
+				operationId: operation.id,
+				tags: [...operation.tags],
+				...operation.summary === void 0 ? {} : { summary: operation.summary },
+				successStatus: successOf(operation),
+				inputStructure: source.kind === "verb" ? "compact" : "detailed"
+			},
+			run
+		}];
+	});
+}
+//#endregion
 //#region src/bridges/orpc.ts
 /**
 * Runs an entry array around an oRPC fetch handler. The procedures' initial
@@ -80,7 +222,7 @@ function createOrpc(betterSupabase, options = {}) {
 		if ("kind" in caller) throw toOrpcError(caller);
 		try {
 			return await next({ context: {
-				bs: ctx,
+				bsb: ctx,
 				db: ctx.db,
 				auth: ctx.auth
 			} });
@@ -133,30 +275,22 @@ function createOrpc(betterSupabase, options = {}) {
 			if (!settled.ok) throw toOrpcError(settled.error);
 			return settled.data;
 		},
-		blockRouter(client, routerOptions) {
+		router(api, routerOptions = {}) {
 			const procedures = {};
 			const routes = [];
-			const schemas = routerOptions.schemas ?? {};
-			for (const name of routerOptions.methods) {
-				const route = {
-					method: "POST",
-					path: `/${routerOptions.name}/${name}`,
-					operationId: `${routerOptions.name}.${name}`
-				};
-				const schema = schemas[name];
+			for (const { route, run } of apiProcedures(betterSupabase, options.authorizer, api, routerOptions.resources)) {
 				const base = os.$context().use(middleware(routerOptions.guard));
 				const routed = routerOptions.meta ? base.meta(routerOptions.meta(route)) : base;
-				const call = async ({ input, context }) => {
-					const settled = await settle(() => callWithInput(client(context.bs), name, input));
+				procedures[route.operationId] = routed.handler(async ({ input, context }) => {
+					const settled = await settle(() => run({
+						input,
+						db: context.db,
+						request: context.request
+					}));
 					if (!settled.ok) throw toOrpcError(settled.error);
 					return settled.data;
-				};
-				procedures[name] = schema ? routed.input(schema).handler(call) : routed.handler(call);
-				routes.push({
-					...route,
-					...schema ? { input: schema } : {},
-					...routerOptions.tags ? { tags: routerOptions.tags } : {}
 				});
+				routes.push(route);
 			}
 			return {
 				procedures,

package/dist/otel/index.d.ts

@@ -1,6 +1,6 @@
-import { o as EventHub } from "../events-DbLjvxDX.js";
-import { d as Plugin } from "../plugin-Ar5546xh.js";
-import { t as SPEC_PINS } from "../spec-pins-CZ2CL8YZ.js";
+import { Mt as Plugin } from "../types-DFdg_4yN.js";
+import { o as EventHub } from "../events-vcqenSYU.js";
+import { t as SPEC_PINS } from "../spec-pins-DIx95afw.js";
 import { Attributes, Meter, Tracer } from "@opentelemetry/api";
 //#region src/otel/index.d.ts
 export declare const INSTRUMENTATION_NAME = "better-supabase";

package/dist/otel/index.js

@@ -1,5 +1,5 @@
-import { r as definePlugin } from "../plugin-D9bYbYli.js";
-import { t as SPEC_PINS } from "../spec-pins-D3Tm6HJi.js";
+import { r as definePlugin } from "../plugin-AKwwe2gF.js";
+import { t as SPEC_PINS } from "../spec-pins-C1Vm8OBl.js";
 import { i as blockEventAttributes } from "../block-events-pBXPzwnW.js";
 import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 //#endregion
@@ -40,9 +40,9 @@ function systemOf(executor) {
 * ```
 */
 function otel(options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.14.0");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.15.0");
 	let histogram;
-	if (options.metrics !== false) histogram = (options.meter ?? metrics.getMeter("better-supabase", "0.14.0")).createHistogram("db.client.operation.duration", {
+	if (options.metrics !== false) histogram = (options.meter ?? metrics.getMeter("better-supabase", "0.15.0")).createHistogram("db.client.operation.duration", {
 		unit: "s",
 		description: "Duration of database client operations.",
 		advice: { explicitBucketBoundaries: [
@@ -219,7 +219,7 @@ function otel(options = {}) {
 * `betterSupabase.events`. Returns a function that stops listening.
 */
 function traceAuth(betterSupabase, options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.14.0");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.15.0");
 	const offAuth = betterSupabase.events.on("auth", (event) => {
 		const span = tracer.startSpan("auth.resolve", {
 			kind: SpanKind.INTERNAL,
@@ -257,7 +257,7 @@ function traceAuth(betterSupabase, options = {}) {
 * an error status. Returns a function that stops listening.
 */
 function traceBlockEvents(betterSupabase, options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.14.0");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.15.0");
 	return betterSupabase.events.on("block", (event) => {
 		const attributes = {
 			...options.attributes,