better-supabase 0.0.0 → 0.1.0

package/dist/events-2OJsVG_d.d.ts

@@ -0,0 +1,84 @@
+import { g as Operation } from "./executor-Bazhgsgq.js";
+import { p as DbError } from "./result-CTkCZ6JA.js";
+import { h as RequestContext, l as MutationKind } from "./plugin-HvGqCurB.js";
+//#region src/core/logger.d.ts
+type LogFields = Readonly<Record<string, unknown>>;
+/**
+ * Where better-supabase reports problems it swallows on purpose: event
+ * handlers, `afterMutation` hooks, sinks and cache adapters that throw.
+ * Structured loggers (pino, consola, OpenTelemetry logs) fit directly.
+ */
+interface Logger {
+  debug(message: string, fields?: LogFields): void;
+  info(message: string, fields?: LogFields): void;
+  warn(message: string, fields?: LogFields): void;
+  error(message: string, fields?: LogFields): void;
+}
+/** The default: `console`, with a `better-supabase:` prefix. */
+declare const consoleLogger: Logger;
+declare const silentLogger: Logger;
+//#endregion
+//#region src/core/events.d.ts
+interface QueryEvent {
+  readonly table: string;
+  readonly operation: Operation["kind"];
+  readonly ok: boolean;
+  readonly durationMs: number;
+  readonly rows: number;
+  /**
+   * An unbounded read returned `maxRows` rows: PostgREST's `db-max-rows`
+   * probably cut it short. Add `limit` or use `paginate`.
+   */
+  readonly truncated: boolean;
+}
+interface MutationNotice {
+  readonly table: string;
+  readonly kind: MutationKind;
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  readonly context: RequestContext;
+}
+/** A successful RPC registered with `sb.defineRpc(name, { invalidates })`. */
+interface RpcNotice {
+  readonly name: string;
+  /** App keys of the tables the function changes. */
+  readonly invalidates: readonly string[];
+  readonly context: RequestContext;
+}
+interface ErrorEvent {
+  readonly table?: string;
+  readonly error: DbError;
+}
+interface AuthEvent {
+  readonly source: "bearer" | "cookie" | "none";
+  readonly ok: boolean;
+  readonly userId?: string;
+}
+interface RefreshEvent {
+  readonly ok: boolean;
+  readonly shared: boolean;
+  readonly durationMs: number;
+}
+interface BetterSupabaseEvents {
+  query: QueryEvent;
+  mutation: MutationNotice;
+  rpc: RpcNotice;
+  error: ErrorEvent;
+  auth: AuthEvent;
+  refresh: RefreshEvent;
+}
+type EventName = keyof BetterSupabaseEvents;
+type EventHandler<K extends EventName> = (event: BetterSupabaseEvents[K]) => void;
+/**
+ * Observers only: a handler that throws is reported to the logger and never
+ * changes a result.
+ */
+declare class EventHub {
+  #private;
+  readonly logger: Logger;
+  constructor(logger?: Logger);
+  on<K extends EventName>(name: K, handler: EventHandler<K>): () => void;
+  has(name: EventName): boolean;
+  emit<K extends EventName>(name: K, event: BetterSupabaseEvents[K]): void;
+}
+//#endregion
+export { EventHub as a, QueryEvent as c, LogFields as d, Logger as f, EventHandler as i, RefreshEvent as l, silentLogger as m, BetterSupabaseEvents as n, EventName as o, consoleLogger as p, ErrorEvent as r, MutationNotice as s, AuthEvent as t, RpcNotice as u };

package/dist/events-BuzTgn2D.js

@@ -0,0 +1,135 @@
+//#region src/events/index.ts
+const ROW_EVENT_TYPES = {
+	insert: "dev.better-supabase.row.created",
+	upsert: "dev.better-supabase.row.upserted",
+	update: "dev.better-supabase.row.updated",
+	delete: "dev.better-supabase.row.deleted"
+};
+function subjectOf(meta, table, row) {
+	const key = meta?.tables[table]?.primaryKey;
+	if (!key || key.length === 0) return void 0;
+	const values = key.map((column) => row[column]);
+	if (values.some((value) => value === void 0 || value === null)) return void 0;
+	return `${table}/${values.map((value) => encodeURIComponent(String(value))).join(",")}`;
+}
+/**
+* One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
+* app-cased row as `data`, the primary key as `subject`, the tenant as
+* `partitionkey` and the actor as `actorid`.
+*/
+function toCloudEvents(notice, options) {
+	const type = options.typePrefix ? `${options.typePrefix}.row.${ROW_EVENT_TYPES[notice.kind].split(".").at(-1)}` : ROW_EVENT_TYPES[notice.kind];
+	const time = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+	return notice.rows.map((row) => {
+		const subject = subjectOf(options.meta, notice.table, row);
+		return {
+			specversion: "1.0",
+			id: options.id?.() ?? crypto.randomUUID(),
+			source: options.source,
+			type,
+			...subject ? { subject } : {},
+			time,
+			datacontenttype: "application/json",
+			data: {
+				table: notice.table,
+				row
+			},
+			...notice.context.tenant ? { partitionkey: notice.context.tenant } : {},
+			...notice.context.actor?.id ? { actorid: notice.context.actor.id } : {}
+		};
+	});
+}
+/**
+* Sends a CloudEvent for every mutation to `sink`. Returns a function that
+* stops forwarding. Use an outbox (SQL kit) when events must not be lost.
+*/
+function forwardMutations(sb, sink, options) {
+	return sb.events.on("mutation", (notice) => {
+		if (options.filter && !options.filter(notice)) return;
+		const events = toCloudEvents(notice, {
+			...options,
+			meta: sb.meta
+		});
+		if (events.length === 0) return;
+		const report = (error) => (options.onError ?? ((cause) => sb.events.logger.error("event sink failed", { cause })))(error, events);
+		try {
+			Promise.resolve(sink.send(events)).catch(report);
+		} catch (error) {
+			report(error);
+		}
+	});
+}
+const STRUCTURED = "application/cloudevents+json";
+const BATCH = "application/cloudevents-batch+json";
+/** The HTTP protocol binding: headers and body for one event (or a batch). */
+function toHttp(events, mode = "structured") {
+	const list = Array.isArray(events) ? events : [events];
+	switch (mode) {
+		case "batch": return [{
+			headers: { "content-type": BATCH },
+			body: JSON.stringify(list)
+		}];
+		case "structured": return list.map((event) => ({
+			headers: { "content-type": STRUCTURED },
+			body: JSON.stringify(event)
+		}));
+		case "binary": return list.map((event) => {
+			const headers = {};
+			for (const [key, value] of Object.entries(event)) {
+				if (key === "data" || key === "datacontenttype" || value === void 0) continue;
+				headers[`ce-${key}`] = encodeURIComponent(String(value)).replace(/%20/g, " ");
+			}
+			headers["content-type"] = event.datacontenttype ?? "application/json";
+			return {
+				headers,
+				body: event.data === void 0 ? "" : JSON.stringify(event.data)
+			};
+		});
+		default: throw new TypeError(`Unknown CloudEvents mode ${String(mode)}`);
+	}
+}
+function isCloudEvent(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const event = value;
+	return event["specversion"] === "1.0" && typeof event["id"] === "string" && typeof event["source"] === "string" && typeof event["type"] === "string";
+}
+/** Reads CloudEvents from a request in any of the three HTTP modes. */
+async function fromHttp(request) {
+	const contentType = request.headers.get("content-type") ?? "";
+	const text = await request.text();
+	if (contentType.startsWith(BATCH)) {
+		const parsed = JSON.parse(text);
+		if (!Array.isArray(parsed) || !parsed.every(isCloudEvent)) throw new TypeError("Invalid CloudEvents batch");
+		return parsed;
+	}
+	if (contentType.startsWith(STRUCTURED)) {
+		const parsed = JSON.parse(text);
+		if (!isCloudEvent(parsed)) throw new TypeError("Invalid CloudEvent");
+		return [parsed];
+	}
+	const event = {};
+	for (const [key, value] of request.headers) if (key.startsWith("ce-")) event[key.slice(3)] = decodeURIComponent(value);
+	if (contentType) event["datacontenttype"] = contentType;
+	if (text) event["data"] = /json/.test(contentType) ? JSON.parse(text) : text;
+	if (!isCloudEvent(event)) throw new TypeError("Request is not a CloudEvent");
+	return [event];
+}
+/** POSTs events to `url`. Non-2xx responses reject. */
+function httpSink(url, options = {}) {
+	const send = options.fetch ?? fetch;
+	return { async send(events) {
+		for (const message of toHttp(events, options.mode ?? "batch")) {
+			const response = await send(url, {
+				method: "POST",
+				headers: {
+					...options.headers,
+					...message.headers
+				},
+				body: message.body
+			});
+			if (!response.ok) throw new Error(`Event sink responded ${String(response.status)}`);
+		}
+	} };
+}
+//#endregion
+export { isCloudEvent as a, httpSink as i, forwardMutations as n, toCloudEvents as o, fromHttp as r, toHttp as s, ROW_EVENT_TYPES as t };

package/dist/executor-Bazhgsgq.d.ts

@@ -0,0 +1,195 @@
+import { A as TableMeta, o as Codec, x as RelationMeta } from "./types-C2fslP1z.js";
+import { o as Result, v as ErrorMapper } from "./result-CTkCZ6JA.js";
+//#region src/ir/types.d.ts
+/**
+ * The query IR. Every repository call becomes one of these operations; the
+ * executor compiles it to PostgREST or SQL. Column names in the IR are
+ * database names; `Selection` carries the app aliases.
+ */
+type ColumnOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "is" | "like" | "ilike" | "contains" | "containedBy" | "overlaps" | "fts";
+type Quantifier = "some" | "none" | "every";
+type Condition = {
+  readonly kind: "and";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "or";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "not";
+  readonly item: Condition;
+} | {
+  readonly kind: "column";
+  readonly column: string;
+  readonly op: ColumnOp;
+  readonly value: unknown;
+  /** Full-text search configuration for `fts`. */
+  readonly config?: string;
+} | {
+  readonly kind: "relation";
+  readonly name: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly quantifier: Quantifier;
+  readonly where: Condition | undefined;
+};
+interface SelectColumn {
+  /** Key in the returned row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the column as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  /** Decodes the returned value (see `ColumnMeta.codec`). */
+  readonly codec?: Codec;
+}
+interface OrderTerm {
+  readonly column: string;
+  readonly direction: "asc" | "desc";
+  readonly nulls?: "first" | "last";
+}
+interface Include {
+  readonly alias: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  /** Drop parent rows without a match (`!inner`). */
+  readonly required: boolean;
+  /**
+   * `_count` include: returns the number of matching related rows instead of
+   * rows, folded into `row._count[count]` when decoded.
+   */
+  readonly count?: string;
+  /**
+   * `_sum`/`_avg`/`_min`/`_max` include: `selection.aggregate` holds the
+   * measures, folded into `row[`_${fn}`][name]` when decoded.
+   */
+  readonly aggregate?: {
+    readonly fn: AggregateFn;
+    readonly name: string;
+  };
+}
+type AggregateFn = "sum" | "avg" | "min" | "max";
+interface Measure {
+  readonly fn: AggregateFn;
+  /** Key in the returned row (`_sum_amount`, or the column alias in an include). */
+  readonly key: string;
+  /** App column name, the key under `_sum` in the decoded row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the result as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  readonly codec?: Codec;
+}
+/**
+ * Aggregates instead of rows. `Selection.columns` become the grouping
+ * columns; without any, the result is exactly one row.
+ */
+interface Aggregation {
+  /** Also return `_count`, the number of rows in each group. */
+  readonly count: boolean;
+  readonly measures: readonly Measure[];
+}
+interface Selection {
+  readonly columns: readonly SelectColumn[];
+  readonly includes: readonly Include[];
+  readonly aggregate?: Aggregation;
+}
+type CountMode = "exact" | "planned" | "estimated";
+interface SelectOp {
+  readonly kind: "select";
+  readonly table: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  readonly offset: number | undefined;
+  readonly count: CountMode | undefined;
+  /** Only count, return no rows. */
+  readonly head: boolean;
+  readonly single: "one" | "maybe" | undefined;
+  /**
+   * Read from this set-returning function instead of the table (`db.$search`).
+   * Only executors with `functionSources` honor it.
+   */
+  readonly source?: FunctionSource;
+}
+/** A function returning `setof <table>`, called with named arguments. */
+interface FunctionSource {
+  readonly schema: string;
+  readonly name: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+interface InsertOp {
+  readonly kind: "insert";
+  readonly table: TableMeta;
+  /** Rows keyed by database column names. */
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  readonly returning: Selection | undefined;
+  readonly onConflict: {
+    readonly columns: readonly string[];
+    readonly action: "update" | "ignore";
+  } | undefined;
+  /** Missing columns become `null` instead of their default in bulk inserts. */
+  readonly defaultToNull: boolean;
+}
+interface UpdateOp {
+  readonly kind: "update";
+  readonly table: TableMeta;
+  /** Keyed by database column names. */
+  readonly set: Readonly<Record<string, unknown>>;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+interface DeleteOp {
+  readonly kind: "delete";
+  readonly table: TableMeta;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+type Operation = SelectOp | InsertOp | UpdateOp | DeleteOp;
+type MutationOp = InsertOp | UpdateOp | DeleteOp;
+declare const and: (...items: (Condition | undefined)[]) => Condition | undefined;
+declare const or: (...items: Condition[]) => Condition;
+declare const not: (item: Condition) => Condition;
+declare const column: (name: string, op: ColumnOp, value: unknown) => Condition;
+//#endregion
+//#region src/core/executor.d.ts
+interface ExecuteContext {
+  readonly signal?: AbortSignal;
+  readonly errorMappers: readonly ErrorMapper[];
+}
+interface ExecuteResult {
+  /** Rows keyed by the aliases in the operation's selection. */
+  readonly rows: readonly Record<string, unknown>[];
+  readonly count: number | null;
+}
+/**
+ * Runs IR operations. PostgREST (`postgrestExecutor`) and SQL
+ * (`better-supabase/postgres`) are built in; any other backend can implement
+ * this interface and prove it with `testExecutor` from `better-supabase/testing`.
+ */
+interface Executor {
+  readonly name: string;
+  /** Honors `SelectOp.source`. `db.$search` fails on executors without it. */
+  readonly functionSources?: boolean;
+  execute(op: Operation, context: ExecuteContext): Promise<Result<ExecuteResult>>;
+  /** Calls a database function. Optional; `db.$rpc` fails without it. */
+  rpc?(name: string, args: Readonly<Record<string, unknown>>, context: RpcContext): Promise<Result<unknown>>;
+  /**
+   * Runs several reads together, for `db.$many`: one transaction on a SQL
+   * connection. Returns one result per operation, in order. Optional;
+   * without it `db.$many` runs the operations in parallel.
+   */
+  batch?(ops: readonly Operation[], context: ExecuteContext): Promise<readonly Result<ExecuteResult>[]>;
+}
+interface RpcContext extends ExecuteContext {
+  readonly schema: string;
+  /** The function is `stable`: send it as a GET, so read replicas can serve it. */
+  readonly get?: boolean;
+}
+//#endregion
+export { and as C, or as E, UpdateOp as S, not as T, OrderTerm as _, AggregateFn as a, SelectOp as b, Condition as c, FunctionSource as d, Include as f, Operation as g, MutationOp as h, RpcContext as i, CountMode as l, Measure as m, ExecuteResult as n, Aggregation as o, InsertOp as p, Executor as r, ColumnOp as s, ExecuteContext as t, DeleteOp as u, Quantifier as v, column as w, Selection as x, SelectColumn as y };

package/dist/executor-Bje4suQF.d.ts

@@ -0,0 +1,25 @@
+import { r as Executor } from "./executor-Bazhgsgq.js";
+import { y as RawDbError } from "./result-CTkCZ6JA.js";
+//#region src/postgres/executor.d.ts
+/**
+ * Anything that runs parameterized SQL: `ctx.postgres` from
+ * `@supabase/server/middleware/postgres`, or a client from `createPostgres()`.
+ */
+interface SqlClient {
+  queryRaw<T = Record<string, unknown>>(text: string, params?: unknown[]): Promise<T[]>;
+  /**
+   * Runs `fn` on one connection in one transaction. Optional; without it
+   * `db.$many` sends its statements separately.
+   */
+  transaction?<T>(fn: (client: SqlClient) => Promise<T>): Promise<T>;
+}
+/** node-postgres error fields to the shape `mapDbError` reads. */
+declare function fromPgError(error: unknown): RawDbError | undefined;
+/**
+ * Executes repository operations as SQL on a direct Postgres connection.
+ * Rows have the same shape as over PostgREST. RLS applies when the client
+ * runs as the caller (`ctx.postgres`, `createPostgres().asUser()`).
+ */
+declare function postgresExecutor(client: SqlClient): Executor;
+//#endregion
+export { fromPgError as n, postgresExecutor as r, SqlClient as t };

package/dist/executor-Ceq60hPM.js

@@ -0,0 +1,89 @@
+import { c as mapDbError, n as dbError } from "./errors-Bl3rkOzo.js";
+import { i as ok, n as err, o as toDbError } from "./result-DWXatkd6.js";
+import { t as compileSql } from "./sql-M8l3fnS0.js";
+//#region src/postgres/executor.ts
+function isPgError(value) {
+	return typeof value === "object" && value !== null && typeof value.code === "string";
+}
+/** node-postgres error fields to the shape `mapDbError` reads. */
+function fromPgError(error) {
+	if (!isPgError(error)) return void 0;
+	const raw = {};
+	if (error.code !== void 0) raw.code = error.code;
+	if (error.message !== void 0) raw.message = error.message;
+	if (error.detail !== void 0) raw.details = error.detail;
+	if (error.hint !== void 0) raw.hint = error.hint;
+	if (error.constraint !== void 0) raw.constraint = error.constraint;
+	if (error.column !== void 0) raw.column = error.column;
+	if (error.table !== void 0) raw.table = error.table;
+	return raw;
+}
+async function run(client, plan, op) {
+	const rows = plan.rows ? (await client.queryRaw(plan.rows.text, [...plan.rows.params])).map((entry) => entry.row) : [];
+	let count = null;
+	if (plan.count) {
+		const [first] = await client.queryRaw(plan.count.text, [...plan.count.params]);
+		count = first?.count ?? 0;
+	} else if (op.kind !== "select") count = rows.length;
+	return {
+		rows,
+		count
+	};
+}
+/**
+* Executes repository operations as SQL on a direct Postgres connection.
+* Rows have the same shape as over PostgREST. RLS applies when the client
+* runs as the caller (`ctx.postgres`, `createPostgres().asUser()`).
+*/
+function postgresExecutor(client) {
+	return {
+		name: "postgres",
+		functionSources: true,
+		execute: (op, context) => executeOn(client, op, context),
+		async batch(ops, context) {
+			if (!client.transaction) return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			try {
+				return await client.transaction(async (scoped) => {
+					const results = [];
+					for (const op of ops) {
+						const result = await executeOn(scoped, op, context);
+						if (!result.ok) throw new BatchFailed();
+						results.push(result);
+					}
+					return results;
+				});
+			} catch (cause) {
+				if (!(cause instanceof BatchFailed)) throw cause;
+				return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			}
+		}
+	};
+}
+var BatchFailed = class extends Error {};
+async function executeOn(client, op, context) {
+	let plan;
+	try {
+		plan = compileSql(op);
+	} catch (cause) {
+		return err(toDbError(cause));
+	}
+	if (plan.never) return ok({
+		rows: [],
+		count: 0
+	});
+	if (context.signal?.aborted) return err(dbError("aborted", "The request was aborted"));
+	let result;
+	try {
+		result = await run(client, plan, op);
+	} catch (cause) {
+		const raw = fromPgError(cause);
+		return err(raw ? mapDbError(raw, context.errorMappers) : toDbError(cause));
+	}
+	if (op.kind === "select" && op.single) {
+		if (result.rows.length > 1) return err(dbError("multiple_rows", `Expected one ${op.table.key} row`));
+		if (result.rows.length === 0 && op.single === "one") return err(dbError("not_found", `No ${op.table.key} row matched`));
+	}
+	return ok(result);
+}
+//#endregion
+export { postgresExecutor as n, fromPgError as t };

package/dist/hono/index.d.ts

@@ -0,0 +1,45 @@
+import { k as TableKey, n as AnyModels, t as AnyFunctions } from "../types-C2fslP1z.js";
+import { t as BetterSupabase } from "../define-CTfWw-SS.js";
+import { r as AuthState } from "../resolve-DW8h9NPm.js";
+import { d as ServerContext, f as ServerOptions, l as BetterServer, n as GuardOptions } from "../respond-PoTpy5DT.js";
+import { i as ResourceRouteOptions } from "../resource-SkPTRJDD.js";
+import { Context, ErrorHandler, Hono, MiddlewareHandler } from "hono";
+//#region src/hono/index.d.ts
+/** Hono `Env` with the request's better-supabase context in `c.var`. */
+export interface BetterEnv<M extends AnyModels, F extends AnyFunctions, E> {
+  Variables: {
+    readonly bs: ServerContext<M, F, E>;
+    readonly db: ServerContext<M, F, E>["db"];
+    readonly auth: AuthState;
+  };
+}
+export interface HonoOptions extends ServerOptions {
+  /** Include error details in problem responses. Defaults to `NODE_ENV === 'development'`. */
+  readonly exposeErrors?: boolean;
+}
+export interface MiddlewareOptions extends GuardOptions {
+  /**
+   * Refresh an expired cookie session and send the new cookies. Only for
+   * routes browsers call with cookies; bearer tokens never refresh.
+   */
+  readonly refresh?: boolean;
+}
+export interface BetterHono<M extends AnyModels, F extends AnyFunctions, E> extends BetterServer<M, F, E> {
+  /** Resolves the caller, enforces `allow` and sets `c.var.bs`, `c.var.db`, `c.var.auth`. */
+  middleware(options?: MiddlewareOptions): MiddlewareHandler<BetterEnv<M, F, E>>;
+  /** Wraps a handler: `Result`s become JSON or Problem Details, `undefined` becomes 204. */
+  handle(handler: (c: Context<BetterEnv<M, F, E>>, ctx: ServerContext<M, F, E>) => unknown, options?: {
+    readonly status?: number;
+  }): (c: Context<BetterEnv<M, F, E>>) => Promise<Response>;
+  /** `app.onError(bs.onError)`: `DbException`s (and errors caused by a `DbError`) become Problem Details, others a 500. */
+  readonly onError: ErrorHandler<BetterEnv<M, F, E>>;
+  /**
+   * REST routes for a table matching `createOpenApi`. Mount with
+   * `app.route('/customers', bs.resource('customers'))` behind `middleware()`.
+   */
+  resource<T extends TableKey<M>>(table: T, options?: ResourceRouteOptions<M, T>): Hono<BetterEnv<M, F, E>>;
+}
+/** Hono integration: a server plus middleware, handlers and REST resources. */
+export declare function createHono<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, options?: HonoOptions): BetterHono<M, F, E>;
+//#endregion
+export type { GuardOptions, ResourceRouteOptions };

package/dist/hono/index.js

@@ -0,0 +1,70 @@
+import { n as dbError, r as dbErrorOf } from "../errors-Bl3rkOzo.js";
+import { a as problemResponse } from "../problem-DPu6Fh-t.js";
+import { i as respond, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-4-dhoV7x.js";
+import { t as defineResource } from "../resource-CYiu6Ygi.js";
+import { Hono } from "hono";
+//#region src/hono/index.ts
+function contextOf(c) {
+	const ctx = c.get("bs");
+	if (!ctx) throw new TypeError("better-supabase: no context on this request; add app.use(bs.middleware()) first");
+	return ctx;
+}
+/** Hono integration: a server plus middleware, handlers and REST resources. */
+function createHono(sb, options = {}) {
+	const server = createServer(sb, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const onError = (cause, c) => {
+		const instance = new URL(c.req.url).pathname;
+		const thrown = dbErrorOf(cause);
+		if (thrown) return problemResponse(thrown, {
+			instance,
+			expose
+		});
+		const error = dbError("unexpected", expose ? cause.message : "Internal server error", { status: 500 });
+		return problemResponse(error, {
+			instance,
+			expose
+		});
+	};
+	return extendServer(server, {
+		onError,
+		middleware(middlewareOptions = {}) {
+			return async (c, next) => {
+				const ctx = await server.context(c.req.raw, { refresh: middlewareOptions.refresh ?? false });
+				const denied = guard(ctx.auth, middlewareOptions.allow, middlewareOptions.aal);
+				if (denied) return ctx.resolution.apply(problemResponse(denied, {
+					instance: new URL(c.req.url).pathname,
+					expose
+				}));
+				c.set("bs", ctx);
+				c.set("db", ctx.db);
+				c.set("auth", ctx.auth);
+				await next();
+				c.res = ctx.resolution.apply(c.res);
+			};
+		},
+		handle(handler, handleOptions = {}) {
+			return (c) => {
+				const ctx = contextOf(c);
+				return respond(() => handler(c, ctx), {
+					instance: new URL(c.req.url).pathname,
+					expose,
+					...handleOptions
+				});
+			};
+		},
+		resource(table, resourceOptions) {
+			const resource = defineResource(sb, table, resourceOptions);
+			const app = new Hono();
+			const serve = (item) => (c) => resource.handle(c.req.raw, contextOf(c).db, item ? c.req.param("id") : void 0, {
+				instance: new URL(c.req.url).pathname,
+				expose
+			});
+			app.all("/", serve(false));
+			if (resource.keyParam) app.all("/:id", serve(true));
+			return app;
+		}
+	});
+}
+//#endregion
+export { createHono };