better-supabase 0.13.0 → 0.15.0

package/dist/options-DWbA9buW.js

@@ -0,0 +1,9 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/trash/options.ts
+const trashSqlOptions = blockOptions({
+	retentionDays: option.number({ default: 30 }),
+	extraColumns: option.unknown(),
+	deletedAt: option.string({ default: "deleted_at" })
+});
+//#endregion
+export { trashSqlOptions as t };

package/dist/options-DXnBN2E7.js

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

package/dist/options-D_bBVCXg.js

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

package/dist/options-DcOx8_3X.d.ts

@@ -0,0 +1,19 @@
+import { t as BlockOptionsSchema } from "./options-CsGl5BLH.js";
+//#region src/blocks/passes/options.d.ts
+/** `blocks['passes'].options`. */
+type PassesSqlOptions = {
+  /** How long before a booking starts its ticket admits, as a Postgres interval. */
+  readonly checkInOpens?: string;
+  /** How long a drop-in counts against a resource's capacity. */
+  readonly dropInLength?: string;
+  /**
+   * Lets a pass with a number of uses pay for bookings. Needs bookings. Off by
+   * default.
+   */
+  readonly credits?: boolean;
+  /** How long before a class a cancellation still refunds its credit. */
+  readonly creditRefundBefore?: string;
+};
+declare const passesSqlOptions: BlockOptionsSchema<PassesSqlOptions>;
+//#endregion
+export { passesSqlOptions as n, PassesSqlOptions as t };

package/dist/options-DeNejBtq.js

@@ -0,0 +1,8 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/reactions/options.ts
+const reactionsSqlOptions = blockOptions({ topic: option.string({
+	default: "reactions",
+	client: true
+}) });
+//#endregion
+export { reactionsSqlOptions as t };

package/dist/options-DgQo80Xh.js

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

package/dist/options-DlohRAYd.d.ts

@@ -0,0 +1,13 @@
+//#region src/blocks/moderation/options.d.ts
+/** `blocks.moderation.options`. */
+type ModerationSqlOptions = {
+  /**
+   * Open reports that hide visible content until a moderator decides; 0 turns
+   * it off.
+   */
+  readonly autoHideThreshold?: number;
+  /** The reasons a report may give, as lower-case keys. */
+  readonly reasons?: readonly string[];
+};
+//#endregion
+export { ModerationSqlOptions as t };

package/dist/options-DplE18Ko.d.ts

@@ -0,0 +1,12 @@
+import { t as BlockOptionsSchema } from "./options-CsGl5BLH.js";
+//#region src/blocks/mail-sync/options.d.ts
+/** `blocks.mail-sync.options`. */
+type MailSyncSqlOptions = {
+  /** The engagement type shared threads are logged as. Default `email`. */
+  readonly engagementType?: string;
+  /** Also links a thread to companies by the domain of its addresses. */
+  readonly matchDomains?: boolean;
+};
+declare const mailSyncSqlOptions: BlockOptionsSchema<MailSyncSqlOptions>;
+//#endregion
+export { mailSyncSqlOptions as n, MailSyncSqlOptions as t };

package/dist/options-DrSkIBCD.js

@@ -0,0 +1,9 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/comments/options.ts
+const commentsSqlOptions = blockOptions({
+	follow: option.boolean({ default: true }),
+	mentionGroups: option.unknown(),
+	notify: option.boolean({ default: true })
+});
+//#endregion
+export { commentsSqlOptions as t };

package/dist/options-E7KcmHQv.js

@@ -0,0 +1,8 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/contracts/options.ts
+const contractsSqlOptions = blockOptions({
+	reminderDays: option.number({ default: 14 }),
+	extraColumns: option.unknown()
+});
+//#endregion
+export { contractsSqlOptions as t };

package/dist/options-HLwOuF2H.js

@@ -0,0 +1,10 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/queue/options.ts
+const queueSqlOptions = blockOptions({
+	backend: option.string({ default: "pgmq" }),
+	scheduler: option.string({ default: "pg_cron" })
+});
+const rateLimitSqlOptions = blockOptions({ preRequest: option.boolean({ default: true }) });
+const webhookInboxSqlOptions = blockOptions({ extraColumns: option.unknown() });
+//#endregion
+export { rateLimitSqlOptions as n, webhookInboxSqlOptions as r, queueSqlOptions as t };

package/dist/options-IHPg8ZoA.js

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

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-o2kfYU2x.js

@@ -0,0 +1,8 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/bookings/options.ts
+const bookingsSqlOptions = blockOptions({
+	extraColumns: option.unknown(),
+	recurring: option.boolean({ default: false })
+});
+//#endregion
+export { bookingsSqlOptions 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-t_O5ldT6.js

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

package/dist/options-xD4_FRUq.js

@@ -0,0 +1,10 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/passes/options.ts
+const passesSqlOptions = blockOptions({
+	checkInOpens: option.string({ default: "1 hour" }),
+	dropInLength: option.string({ default: "2 hours" }),
+	credits: option.boolean({ default: false }),
+	creditRefundBefore: option.string({ default: "12 hours" })
+});
+//#endregion
+export { passesSqlOptions 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/options-zkyhM3qi.js

@@ -0,0 +1,8 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/mail-sync/options.ts
+const mailSyncSqlOptions = blockOptions({
+	engagementType: option.string(),
+	matchDomains: option.boolean()
+});
+//#endregion
+export { mailSyncSqlOptions as t };

package/dist/orpc/index.d.ts

@@ -1,15 +1,55 @@
-import { b as DbError, f as Result } from "../result-mijqfoJN.js";
-import { a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
-import { r as AuthState } from "../resolve-D57oDWNr.js";
-import { i as ProblemDetails } from "../problem-D_DEBfMn.js";
-import { t as BetterSupabase } from "../define-D0LSXmUP.js";
-import { a as ServerContext, c as ServerOptions, n as BetterServer } from "../server-types-D_cQ6OxZ.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-QW-f1yio.js";
-import { c as ResourceLoaderContext, i as AuthorizeOptions } from "../kit-LeQGMzLH.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-B7N1ZGl6.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 { BuilderWithMiddlewares, DecoratedMiddleware, ORPCError } from "@orpc/server";
+import { AnySchema, BuilderWithMiddlewares, DecoratedMiddleware, DecoratedProcedure, MetaPlugin, ORPCError, Schema } from "@orpc/server";
+//#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
@@ -54,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>;
 }
@@ -94,18 +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;
 }
+/** 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>;
   /**
@@ -113,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>;
@@ -142,10 +182,26 @@ export interface BetterOrpc<M extends AnyModels, F extends AnyFunctions, E, C =
   /** Plain values pass through; thrown `DbException`s become `ORPCError`s. */
   unwrap<T>(value: T | PromiseLike<T>): Promise<T>;
   toOrpcError(error: DbError): ORPCError<string, ProblemDetails>;
+  /**
+   * 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 api = defineApi(betterSupabase, { info, basePath: "/api" });
+   * const { procedures } = bsb.router(api, { meta: openapi });
+   * export const handler = bsb.fetchHandler(
+   *   new OpenAPIHandler(os.router(procedures)),
+   * );
+   * ```
+   */
+  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,14 +1,157 @@
-import { r as dbErrorOf } from "../errors-D7u24ZJH.js";
-import { c as toProblem } from "../problem-D0KDiYPk.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 tenantOf } from "../tenant-DnMqeNIM.js";
-import { c as extendServer, n as flushEvents, s as createServer, x as refreshFor } from "../adapter-D8dW6p2A.js";
-import { n as toSession } from "../view-CfUd5vI9.js";
-import { o as settle, r as guard, t as defaultExpose } from "../respond-DjEmE_DN.js";
-import { t as authorizeCaller } from "../kit-BeXTrlZn.js";
-import { t as rateLimitGate } from "../rate-limit-CXpPm4_l.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
@@ -79,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
 			} });
@@ -131,6 +274,28 @@ function createOrpc(betterSupabase, options = {}) {
 			const settled = await settle(() => value);
 			if (!settled.ok) throw toOrpcError(settled.error);
 			return settled.data;
+		},
+		router(api, routerOptions = {}) {
+			const procedures = {};
+			const routes = [];
+			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;
+				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;
+				});
+				routes.push(route);
+			}
+			return {
+				procedures,
+				routes
+			};
 		}
 	});
 }

package/dist/otel/index.d.ts

@@ -1,6 +1,6 @@
-import { o as EventHub } from "../events-DhGgwqQA.js";
-import { d as Plugin } from "../plugin-DouW0Kvg.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";