better-supabase 0.5.1 → 0.6.0

package/dist/executor-BunPOO-k.d.ts

@@ -1,402 +0,0 @@
-import { E as RelationMeta, F as TableMeta, l as Codec } from "./types-Dnf_wRDz.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;
-  /** `limit` includes one row past the page, which `paginate()` reads to set `hasMore`. */
-  readonly lookAhead?: boolean;
-  /**
-   * 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/errors.d.ts
-/**
- * Extra fields carried by each error kind. Plugins can add kinds through the
- * `errors` extension point; apps that want the new kinds in the union can add
- * them to this interface.
- */
-interface DbErrorKinds {
-  not_found: Record<never, never>;
-  unauthorized: Record<never, never>;
-  /**
-   * `required`: the assurance level the route needs, when a second factor is
-   * missing. `scopes`: the OAuth scopes the route needs, when a delegated
-   * token lacks one (`INSUFFICIENT_SCOPE`).
-   */
-  forbidden: {
-    required?: "aal1" | "aal2";
-    scopes?: readonly string[];
-  };
-  conflict: {
-    constraint?: string;
-    columns?: readonly string[];
-  };
-  foreign_key: {
-    constraint?: string;
-    columns?: readonly string[];
-  };
-  check: {
-    constraint?: string;
-  };
-  not_null: {
-    column?: string;
-  };
-  exclusion: {
-    constraint?: string;
-  };
-  invalid_input: Record<never, never>;
-  /** A stored value the app type can't hold, e.g. `infinity` for a Temporal timestamp. */
-  invalid_value: {
-    column?: string;
-  };
-  raised: Record<never, never>;
-  timeout: Record<never, never>;
-  serialization: Record<never, never>;
-  network: Record<never, never>;
-  aborted: Record<never, never>;
-  invalid_request: Record<never, never>;
-  validation: {
-    issues: readonly ValidationIssue[];
-  };
-  multiple_rows: Record<never, never>;
-  stale: Record<never, never>;
-  /** `retryAfter`: seconds until the window resets (the `Retry-After` header). */
-  rate_limited: {
-    retryAfter?: number;
-  };
-  unexpected: Record<never, never>;
-}
-type DbErrorKind = keyof DbErrorKinds;
-interface ValidationIssue {
-  readonly message: string;
-  readonly path?: readonly PropertyKey[];
-}
-interface DbErrorBase<K extends DbErrorKind> {
-  readonly kind: K;
-  readonly message: string;
-  /** SQLSTATE or PostgREST code (`23505`, `PGRST116`), when known. */
-  readonly code?: string;
-  /** Suggested HTTP status, used by the RFC 9457 mapping. */
-  readonly status: number;
-  readonly details?: string;
-  /** Postgres `HINT`. `raised` errors use it as an app-level error code. */
-  readonly hint?: string;
-  /** App-cased table key the operation ran against. */
-  readonly table?: string;
-}
-/**
- * A database error as plain, serializable data. Safe to send across server
- * action and RPC boundaries.
- */
-type DbError = { [K in DbErrorKind]: DbErrorBase<K> & DbErrorKinds[K]; }[DbErrorKind];
-type DbErrorOf<K extends DbErrorKind> = Extract<DbError, {
-  kind: K;
-}>;
-declare function statusOf(kind: DbErrorKind): number;
-type ExtraOf<K extends DbErrorKind> = Record<never, never> extends DbErrorKinds[K] ? [extra?: DbErrorKinds[K] & Partial<Omit<DbErrorBase<K>, "kind">>] : [extra: DbErrorKinds[K] & Partial<Omit<DbErrorBase<K>, "kind">>];
-/** Creates a `DbError` with the default status for its kind. */
-declare function dbError<K extends DbErrorKind>(kind: K, message: string, ...[extra]: ExtraOf<K>): DbErrorOf<K>;
-declare function isDbError(value: unknown): value is DbError;
-/**
- * A unique violation, optionally for one constraint. Accepts a `DbError` or a
- * `DbException`. Pass the generated `UniqueConstraint` type to check names:
- * `isConflict<UniqueConstraint>(error, 'customers_organization_id_kvk_key')`.
- */
-declare const isConflict: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"conflict"> & {
-  readonly constraint: C;
-};
-/** A CHECK violation, optionally for one constraint (`CheckConstraint`). */
-declare const isCheck: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"check"> & {
-  readonly constraint: C;
-};
-/** A foreign key violation, optionally for one constraint (`ForeignKeyConstraint`). */
-declare const isForeignKey: <C extends string = string>(error: unknown, constraint?: NoInfer<C>) => error is DbErrorOf<"foreign_key"> & {
-  readonly constraint: C;
-};
-/** Thrown by `.orThrow()`. Carries the plain `DbError` as `error`. */
-declare class DbException extends Error {
-  override readonly name = "DbException";
-  readonly error: DbError;
-  constructor(error: DbError);
-  get kind(): DbErrorKind;
-}
-/** Raw error shape shared by PostgREST responses and `pg` errors. */
-interface RawDbError {
-  readonly message?: string;
-  readonly code?: string;
-  readonly details?: string | null;
-  readonly hint?: string | null;
-  readonly constraint?: string;
-  readonly column?: string;
-  readonly table?: string;
-  readonly name?: string;
-}
-type ErrorMapper = (raw: RawDbError, fallback: DbError) => DbError | undefined;
-/**
- * Maps a PostgREST or Postgres error to a `DbError`. Custom mappers run
- * first; the first one that returns an error wins.
- */
-declare function mapDbError(raw: RawDbError, mappers?: readonly ErrorMapper[]): DbError;
-//#endregion
-//#region src/core/result.d.ts
-/** Turns a `DbError` into the error `.orThrow()` throws; set with `betterSupabase.mapError()`. */
-type ThrowMapper = (error: DbError) => unknown;
-type Ok<T> = {
-  readonly ok: true;
-  readonly data: T;
-  readonly error: null;
-};
-type Err<E = DbError> = {
-  readonly ok: false;
-  readonly data: null;
-  readonly error: E;
-};
-type Result<T, E = DbError> = Ok<T> | Err<E>;
-declare function ok<T>(data: T): Ok<T>;
-declare function err<E = DbError>(error: E): Err<E>;
-/**
- * A lazy-free `PromiseLike<Result<T>>` with helpers. `await` gives the
- * `Result`; `.orThrow()` gives the data or throws a `DbException`.
- */
-declare class AsyncResult<T> implements PromiseLike<Result<T>> {
-  #private;
-  constructor(promise: Promise<Result<T>>);
-  static from<T>(run: () => Promise<Result<T>>): AsyncResult<T>;
-  static ok<T>(data: T): AsyncResult<T>;
-  static err<T = never>(error: DbError): AsyncResult<T>;
-  then<R1 = Result<T>, R2 = never>(onfulfilled?: ((value: Result<T>) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
-  /**
-   * Resolves with the data, or rejects with a `DbException`. Pass `factory`
-   * to throw your own error instead, e.g. an HTTP error for your framework;
-   * without it, the mapper from `betterSupabase.mapError()` applies when one is set.
-   */
-  orThrow(factory?: (error: DbError) => unknown): Promise<T>;
-  /** Resolves with the data, or `fallback` when the result is an error. */
-  unwrapOr<F>(fallback: F): Promise<T | F>;
-  map<U>(fn: (data: T) => U): AsyncResult<U>;
-  mapError(fn: (error: DbError) => DbError): AsyncResult<T>;
-  andThen<U>(fn: (data: T) => PromiseLike<Result<U>>): AsyncResult<U>;
-}
-/** What `toBetterResult` returns: the `status`/`value`/`error` fields every better-result value has. */
-type BetterResultValue<T, E> = {
-  readonly status: "ok";
-  readonly value: T;
-} | {
-  readonly status: "error";
-  readonly error: E;
-};
-/** The part of better-result's `Result` namespace `toBetterResult` calls. */
-interface BetterResultApi<T, E> {
-  ok(value: NoInfer<T>): unknown;
-  err(error: NoInfer<E>): unknown;
-}
-/**
- * Builds a better-result value with the `Result` namespace you pass, so
- * better-result stays your dependency. Errors go through `mapError`, or, for a
- * result from a `db` of `betterSupabase.mapError(fn)`, through `fn` (typed `unknown`).
- * The value is a real `Ok`/`Err`: cast it (`as Result<T, E>`) for its
- * methods in types; the cast itself is not checked against `T`.
- *
- * ```ts
- * import { Result } from 'better-result';
- * const customer = toBetterResult(await db.customers.findById(id), Result, toAppError);
- * ```
- */
-declare function toBetterResult<T, E>(result: Result<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): BetterResultValue<T, E>;
-declare function toBetterResult<T>(result: Result<T>, api: BetterResultApi<T, DbError>): BetterResultValue<T, DbError>;
-declare function toBetterResult<T, E>(result: AsyncResult<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): Promise<BetterResultValue<T, E>>;
-declare function toBetterResult<T>(result: AsyncResult<T>, api: BetterResultApi<T, unknown>): Promise<BetterResultValue<T, unknown>>;
-/**
- * Converts a better-result value back into a `Result`, by its `status`
- * field, so it works across better-result versions. A `DbError`, or an
- * error whose `cause` is one, is kept; others go through `mapError`
- * (default `toDbError`).
- */
-declare function fromBetterResult<T>(result: BetterResultValue<T, unknown>, mapError?: (error: unknown) => DbError): Result<T>;
-declare function toDbError(cause: unknown): DbError;
-//#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 { or as $, mapDbError as A, InsertOp as B, RawDbError as C, isConflict as D, isCheck as E, Condition as F, Quantifier as G, MutationOp as H, CountMode as I, Selection as J, SelectColumn as K, DeleteOp as L, AggregateFn as M, Aggregation as N, isDbError as O, ColumnOp as P, not as Q, FunctionSource as R, ErrorMapper as S, dbError as T, Operation as U, Measure as V, OrderTerm as W, and as X, UpdateOp as Y, column as Z, DbError as _, AsyncResult as a, DbErrorOf as b, Err as c, ThrowMapper as d, err as f, toDbError as g, toBetterResult as h, RpcContext as i, statusOf as j, isForeignKey as k, Ok as l, ok as m, ExecuteResult as n, BetterResultApi as o, fromBetterResult as p, SelectOp as q, Executor as r, BetterResultValue as s, ExecuteContext as t, Result as u, DbErrorKind as v, ValidationIssue as w, DbException as x, DbErrorKinds as y, Include as z };

package/dist/executor-XycESQPH.js

@@ -1,94 +0,0 @@
-import { c as mapDbError, n as dbError } from "./errors-DtwXa6b8.js";
-import { i as ok, n as err, o as toDbError } from "./result-BKiliPY7.js";
-import { t as compileSql } from "./sql-Coh6n4cC.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;
-	for (const next of plan.chunks ?? []) {
-		const more = await run(client, next, op);
-		rows.push(...more.rows);
-		count = (count ?? 0) + (more.count ?? 0);
-	}
-	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 = plan.chunks && client.transaction ? await client.transaction((scoped) => run(scoped, plan, op)) : 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/index-CWMDdEr4.d.ts

@@ -1,50 +0,0 @@
-import { c as ClaimsMeta, j as SchemaMeta } from "./types-Dnf_wRDz.js";
-import { d as Generator } from "./config-Bv7gvfzC.js";
-//#region src/core/claims.d.ts
-declare const DEFAULT_CLAIMS: ClaimsMeta;
-/** Where the active tenant is read from: the top-level claim, then `app_metadata`. */
-declare function tenantClaimPaths(tenant?: string): readonly [string, string];
-//#endregion
-//#region src/generators/shared.d.ts
-/** What field planning reads: the metadata and the typed-jsonb config. */
-interface SchemaSource {
-  readonly meta: SchemaMeta;
-  readonly config: {
-    readonly json: Readonly<Record<string, unknown>>;
-  };
-}
-//#endregion
-//#region src/generators/json-schema.d.ts
-interface JsonSchemaGeneratorOptions {
-  /** Output path relative to the project root. Defaults to `<output>.schema.json`. */
-  readonly output?: string;
-  /** `$id` of the document. */
-  readonly id?: string;
-}
-type JsonSchema = Record<string, unknown>;
-/** JSON Schema (2020-12) `$defs` for every table: `customersRow`, `customersInsert`, ... */
-declare function buildJsonSchema(input: SchemaSource, id?: string): JsonSchema;
-/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
-declare function jsonSchema(options?: JsonSchemaGeneratorOptions): Generator;
-//#endregion
-//#region src/generators/valibot.d.ts
-interface ValibotGeneratorOptions {
-  /** Output path relative to the project root. Defaults to `<output>.valibot.ts`. */
-  readonly output?: string;
-  /** Schemas for typed jsonb columns: `{ 'customers.metadata': './schemas.ts#metadata' }`. */
-  readonly json?: Readonly<Record<string, string>>;
-}
-/** Valibot schemas for every table's Row, Insert and Update shape. */
-declare function valibot(options?: ValibotGeneratorOptions): Generator;
-//#endregion
-//#region src/generators/zod.d.ts
-interface ZodGeneratorOptions {
-  /** Output path relative to the project root. Defaults to `<output>.zod.ts`. */
-  readonly output?: string;
-  /** Schemas for typed jsonb columns: `{ 'customers.metadata': './schemas.ts#metadata' }`. */
-  readonly json?: Readonly<Record<string, string>>;
-}
-/** Zod 4 schemas for every table's Row, Insert and Update shape. */
-declare function zod(options?: ZodGeneratorOptions): Generator;
-//#endregion
-export { JsonSchemaGeneratorOptions as a, DEFAULT_CLAIMS as c, valibot as i, tenantClaimPaths as l, zod as n, buildJsonSchema as o, ValibotGeneratorOptions as r, jsonSchema as s, ZodGeneratorOptions as t };

package/dist/index-DOESKG27.d.ts

@@ -1,100 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { j as SchemaMeta } from "./types-Dnf_wRDz.js";
-import { a as EventHub, g as KitEventPattern, p as KitEvent, s as MutationNotice } from "./events-aIO7vsIk.js";
-import { l as MutationIntent } from "./plugin-o144f322.js";
-//#region src/events/index.d.ts
-/** A CloudEvents 1.0 event. Extension attributes are lowercase alphanumerics. */
-interface CloudEvent<T = unknown> {
-  readonly specversion: "1.0";
-  readonly id: string;
-  readonly source: string;
-  readonly type: string;
-  readonly subject?: string;
-  readonly time?: string;
-  readonly datacontenttype?: string;
-  readonly dataschema?: string;
-  readonly data?: T;
-  readonly [extension: string]: unknown;
-}
-declare const ROW_EVENT_TYPES: { readonly [K in MutationIntent]: string; };
-interface RowEventData {
-  readonly table: string;
-  readonly row: Readonly<Record<string, unknown>>;
-  readonly actorId?: string;
-}
-interface CloudEventOptions {
-  /** URI-reference of the producer, e.g. `https://crm.example.com` or `/crm`. */
-  readonly source: string;
-  /** Replaces the `dev.better-supabase` type prefix. */
-  readonly typePrefix?: string;
-  readonly id?: () => string;
-  readonly now?: () => Temporal.Instant;
-}
-/** Sends events somewhere: a queue, a bus, an outbox table, an HTTP endpoint. */
-interface EventSink {
-  send(events: readonly CloudEvent[]): void | Promise<void>;
-}
-/**
- * One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
- * app-cased row and the actor in `data`, the primary key as `subject` and the
- * tenant as `partitionkey`. Writes that return no rows (soft
- * deletes, `returning: false`) send one event per known primary key, with the
- * key as `row`.
- */
-declare function toCloudEvents(notice: MutationNotice, options: CloudEventOptions & {
-  readonly meta?: SchemaMeta;
-}): CloudEvent<RowEventData>[];
-interface ForwardOptions extends CloudEventOptions {
-  /** Only forward these tables or kinds. */
-  readonly filter?: (notice: MutationNotice) => boolean;
-  /** Sink failures never fail the mutation. Defaults to the `Logger`. */
-  readonly onError?: (error: unknown, events: readonly CloudEvent[]) => void;
-}
-/**
- * Sends a CloudEvent for every mutation to `sink`. Returns a function that
- * stops forwarding. Sends in flight are tracked on `betterSupabase.events`
- * (`settled()`), which the Next adapter hands to `after()` and the edge
- * entry to `waitUntil`. Use an outbox (SQL kit) when events must not be lost.
- */
-declare function forwardMutations(betterSupabase: {
-  readonly events: EventHub;
-  readonly meta: SchemaMeta;
-}, sink: EventSink, options: ForwardOptions): () => void;
-/**
- * A kit event as a CloudEvent: `dev.better-supabase.support.started` with
- * the event data and the actor (`actorId`) as `data` and the tenant as
- * `partitionkey`.
- */
-declare function kitCloudEvent(event: KitEvent, options: CloudEventOptions): CloudEvent;
-interface ForwardKitOptions extends CloudEventOptions {
-  /** Only forward events that match, e.g. `support.*`. Defaults to all. */
-  readonly types?: readonly KitEventPattern[];
-  /** Sink failures never fail the kit call. Defaults to the `Logger`. */
-  readonly onError?: (error: unknown, events: readonly CloudEvent[]) => void;
-}
-/**
- * Sends a CloudEvent for every kit event (`support.*`, `org.*`, ...) to
- * `sink`. Returns a function that stops forwarding. Like
- * `forwardMutations`, sends are tracked on `betterSupabase.events`.
- */
-declare function forwardKitEvents(betterSupabase: {
-  readonly events: EventHub;
-}, sink: EventSink, options: ForwardKitOptions): () => void;
-type HttpMode = "structured" | "binary" | "batch";
-/** The HTTP protocol binding: headers and body for one event (or a batch). */
-declare function toHttp(events: CloudEvent | readonly CloudEvent[], mode?: HttpMode): {
-  headers: Record<string, string>;
-  body: string;
-}[];
-declare function isCloudEvent(value: unknown): value is CloudEvent;
-/** Reads CloudEvents from a request in any of the three HTTP modes. */
-declare function fromHttp(request: Request): Promise<CloudEvent[]>;
-interface HttpSinkOptions {
-  readonly mode?: HttpMode;
-  readonly headers?: Readonly<Record<string, string>>;
-  readonly fetch?: typeof fetch;
-}
-/** POSTs events to `url`. Non-2xx responses reject. */
-declare function httpSink(url: string | URL, options?: HttpSinkOptions): EventSink;
-//#endregion
-export { toHttp as _, ForwardOptions as a, ROW_EVENT_TYPES as c, forwardMutations as d, fromHttp as f, toCloudEvents as g, kitCloudEvent as h, ForwardKitOptions as i, RowEventData as l, isCloudEvent as m, CloudEventOptions as n, HttpMode as o, httpSink as p, EventSink as r, HttpSinkOptions as s, CloudEvent as t, forwardKitEvents as u };