better-supabase 0.0.0 → 0.2.0

package/dist/respond-Dne1ARSa.d.ts

@@ -0,0 +1,169 @@
+import { n as AnyModels, t as AnyFunctions } from "./types-C83v5SQz.js";
+import { p as DbError, t as AsyncResult } from "./result-CTkCZ6JA.js";
+import { I as StatsRecorder, P as DbStats, t as BetterSupabase, y as Db } from "./define-e3zI4_4g.js";
+import { h as RequestContext } from "./plugin-C4TR9J0Z.js";
+import { t as BetterSupabaseEnv } from "./index-Dy6kuF0P.js";
+import { r as SqlClaims, t as Postgres } from "./pool-R2m_DkXi.js";
+import { o as ImpersonationOptions, t as Aal } from "./mfa-TVia554c.js";
+import { a as ResolveAuthOptions, r as AuthState, t as AuthResolution } from "./resolve-CjHILk2w.js";
+import { n as Bucket } from "./index-DuP14VHo.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+//#region src/server/delete-account.d.ts
+interface DeleteAccountOptions {
+  /**
+   * Buckets to clear first. Objects whose `owner` placeholder (`{userId}`,
+   * or `owner.param` for `owner` buckets) is the user are removed; buckets
+   * without one are skipped.
+   */
+  readonly buckets?: readonly Bucket<string>[];
+  /**
+   * App keys of tables whose rows the database deletes or updates with the
+   * user (`on delete cascade` or `set null` to `auth.users`). They get a
+   * table-wide `mutation` notice, so caches drop their reads.
+   */
+  readonly cascades?: readonly string[];
+  readonly context?: RequestContext;
+  readonly signal?: AbortSignal;
+}
+interface DeleteAccountResult {
+  readonly userId: string;
+  /** Removed objects per bucket id. */
+  readonly removed: Readonly<Record<string, number>>;
+}
+//#endregion
+//#region src/server/replicas.d.ts
+/** Cookie holding the epoch ms until which reads stay on the primary. */
+declare const PRIMARY_COOKIE = "bs-primary-until";
+/** Where a request context sends its reads. */
+interface ReplicaState {
+  /** Reads go to the primary: this context wrote, or a recent request did. */
+  readonly pinned: boolean;
+  /** This context wrote through its repositories (or called `pin()`). */
+  readonly wrote: boolean;
+  /** Sends later reads to the primary, e.g. after a write through `$client` or `$sql`. */
+  pin(): void;
+}
+//#endregion
+//#region src/server/server.d.ts
+interface ServerOptions {
+  /** Defaults to `loadEnv()`. */
+  readonly env?: BetterSupabaseEnv;
+  /** Enables `ctx.sql` and `actingAs()`. */
+  readonly postgres?: Postgres;
+  readonly auth?: Omit<ResolveAuthOptions, "env">;
+  /**
+   * Extra headers on the caller's PostgREST requests, readable in Postgres as
+   * `current_setting('request.headers')` (channel, request id, client IP for audit).
+   */
+  readonly headers?: (request: Request) => Readonly<Record<string, string>>;
+  /**
+   * PostgREST URL for the caller's reads: a read replica or the `<ref>-all`
+   * load balancer. Defaults to `SUPABASE_READ_URL`; `false` reads from the
+   * primary.
+   */
+  readonly readUrl?: string | false;
+  readonly replicas?: {
+    /** How long the next requests read from the primary after a write. Defaults to 5 s. */
+    readonly pinMs?: number;
+  };
+}
+interface ServerContext<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
+  readonly auth: AuthState<C, P>;
+  readonly resolution: AuthResolution<C, P>;
+  /** supabase-js client scoped to the caller (RLS applies). */
+  readonly supabase: SupabaseClient;
+  /** Repositories over PostgREST as the caller. */
+  readonly db: Db<M, F, E, SupabaseClient>;
+  /** Repositories over direct Postgres as the caller, when `postgres` is configured. */
+  readonly sql: Db<M, F, E, undefined> | undefined;
+  /** Calls, waves, tables and time for `db` and `sql` together. */
+  stats(): DbStats;
+  /** Where `db` reads go, when a read URL is configured. */
+  readonly replica: ReplicaState | undefined;
+}
+interface ContextOptions {
+  readonly refresh?: boolean;
+  /** Epoch ms until which `db` reads from the primary (the `bs-primary-until` cookie). */
+  readonly pinnedUntil?: number;
+  /** Also records this context's calls into a request-wide recorder. */
+  readonly stats?: StatsRecorder;
+}
+interface BetterServer<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> {
+  readonly env: BetterSupabaseEnv;
+  resolve(request: Request, options?: {
+    readonly refresh?: boolean;
+  }): Promise<AuthResolution<C, P>>;
+  /**
+   * Resolves auth and binds repositories to the caller. Refreshes an expired
+   * cookie session only with `refresh: true`; send `ctx.resolution.apply(response)`.
+   */
+  context(request: Request, options?: ContextOptions): Promise<ServerContext<M, F, E, C, P>>;
+  /** The context for an auth state resolved elsewhere (the proxy, a queue message). */
+  contextFor(auth: AuthState<C, P>, options?: ContextOptions): ServerContext<M, F, E, C, P>;
+  /** A stateless supabase-js client for an auth state, optionally with extra request headers. */
+  supabaseFor(auth: AuthState, headers?: Readonly<Record<string, string>>): SupabaseClient;
+  /** Repositories for an auth state (e.g. one resolved by the proxy). */
+  dbFor(auth: AuthState, context?: RequestContext): Db<M, F, E, SupabaseClient>;
+  /** Service-role repositories. Bypasses RLS; the actor is `service`. */
+  admin(context?: RequestContext): Db<M, F, E, SupabaseClient>;
+  /**
+   * Deletes a user: their objects in `buckets`, then the Auth user, then a
+   * `mutation` notice for `auth.users`. Needs the secret key. Access tokens
+   * already issued stay valid until they expire.
+   */
+  deleteAccount(userId: string, options?: DeleteAccountOptions): AsyncResult<DeleteAccountResult>;
+  /**
+   * Repositories running as a user, with RLS, over direct Postgres. With
+   * `impersonation`, the claims carry `act: { sub: actor, reason }`, which
+   * the `audit` and `actor` SQL kit modules record.
+   */
+  actingAs(userId: string, claims?: Omit<SqlClaims, "sub" | "act">, impersonation?: ImpersonationOptions): Db<M, F, E, undefined>;
+}
+/**
+ * Server-side entry point for APIs, jobs, MCP servers and framework
+ * adapters. Holds the secrets; `sb` stays isomorphic.
+ */
+declare function createServer<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(sb: BetterSupabase<M, D, F, E, C, P>, options?: ServerOptions): BetterServer<M, F, E, C, P>;
+//#endregion
+//#region src/server/respond.d.ts
+type AuthKind = AuthState["kind"];
+interface GuardOptions {
+  /** Auth kinds allowed through. Defaults to `['user']`. */
+  readonly allow?: readonly Exclude<AuthKind, "invalid">[];
+  /**
+   * Assurance level user sessions need. `aal2` answers 403 with
+   * `required: 'aal2'` until the user verifies a second factor.
+   */
+  readonly aal?: Aal;
+}
+/** `undefined` when `auth` may pass; otherwise the 401/403 error to send. */
+declare function guard(auth: AuthState, allow?: GuardOptions["allow"], aal?: Aal): DbError | undefined;
+declare function isResult(value: unknown): value is {
+  ok: boolean;
+  data: unknown;
+  error: unknown;
+};
+type Settled = {
+  readonly ok: true;
+  readonly data: unknown;
+} | {
+  readonly ok: false;
+  readonly error: DbError;
+};
+/**
+ * Settles a handler's return value: `Result`s and `AsyncResult`s unwrap,
+ * thrown `DbException`s (or errors whose `cause` is a `DbError`) become
+ * errors, anything else is data. Other thrown
+ * errors propagate.
+ */
+declare function settle(run: () => unknown): Promise<Settled>;
+interface RespondOptions {
+  readonly instance?: string;
+  readonly expose?: boolean;
+  /** Status for data responses. Defaults to 200 (204 without data). */
+  readonly status?: number;
+}
+/** A handler's value as a response: `Response` as is, data as JSON, errors as Problem Details. */
+declare function respond(run: () => unknown, options?: RespondOptions): Promise<Response>;
+//#endregion
+export { DeleteAccountResult as _, guard as a, settle as c, ServerContext as d, ServerOptions as f, DeleteAccountOptions as g, ReplicaState as h, Settled as i, BetterServer as l, PRIMARY_COOKIE as m, GuardOptions as n, isResult as o, createServer as p, RespondOptions as r, respond as s, AuthKind as t, ContextOptions as u };

package/dist/result-CTkCZ6JA.d.ts

@@ -0,0 +1,198 @@
+//#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. */
+  forbidden: {
+    required?: "aal1" | "aal2";
+  };
+  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>;
+  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 `sb.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 `sb.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 BetterResultShape<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 `sb.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): BetterResultShape<T, E>;
+declare function toBetterResult<T>(result: Result<T>, api: BetterResultApi<T, DbError>): BetterResultShape<T, DbError>;
+declare function toBetterResult<T, E>(result: AsyncResult<T>, api: BetterResultApi<T, E>, mapError: (error: DbError) => E): Promise<BetterResultShape<T, E>>;
+declare function toBetterResult<T>(result: AsyncResult<T>, api: BetterResultApi<T, unknown>): Promise<BetterResultShape<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: BetterResultShape<T, unknown>, mapError?: (error: unknown) => DbError): Result<T>;
+declare function toDbError(cause: unknown): DbError;
+//#endregion
+export { isConflict as C, statusOf as D, mapDbError as E, isCheck as S, isForeignKey as T, DbException as _, Ok as a, ValidationIssue as b, err as c, toBetterResult as d, toDbError as f, DbErrorOf as g, DbErrorKinds as h, Err as i, fromBetterResult as l, DbErrorKind as m, BetterResultApi as n, Result as o, DbError as p, BetterResultShape as r, ThrowMapper as s, AsyncResult as t, ok as u, ErrorMapper as v, isDbError as w, dbError as x, RawDbError as y };

package/dist/result-DWXatkd6.js

@@ -0,0 +1,103 @@
+import { n as dbError, r as dbErrorOf, t as DbException } from "./errors-Bl3rkOzo.js";
+//#region src/core/result.ts
+const throwMappers = /* @__PURE__ */ new WeakMap();
+function inherit(from, next) {
+	const mapper = throwMappers.get(from);
+	if (mapper) throwMappers.set(next, mapper);
+	return next;
+}
+/** Marks `result` so its `.orThrow()` throws `mapper(error)`; returns it. */
+function withErrorMapper(result, mapper) {
+	throwMappers.set(result, mapper);
+	return result;
+}
+function ok(data) {
+	return {
+		ok: true,
+		data,
+		error: null
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		data: null,
+		error
+	};
+}
+/**
+* A lazy-free `PromiseLike<Result<T>>` with helpers. `await` gives the
+* `Result`; `.orThrow()` gives the data or throws a `DbException`.
+*/
+var AsyncResult = class AsyncResult {
+	#promise;
+	constructor(promise) {
+		this.#promise = promise.catch((cause) => err(toDbError(cause)));
+	}
+	static from(run) {
+		return new AsyncResult(Promise.resolve().then(run));
+	}
+	static ok(data) {
+		return new AsyncResult(Promise.resolve(ok(data)));
+	}
+	static err(error) {
+		return new AsyncResult(Promise.resolve(err(error)));
+	}
+	then(onfulfilled, onrejected) {
+		return this.#promise.then(onfulfilled, onrejected);
+	}
+	/**
+	* 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 `sb.mapError()` applies when one is set.
+	*/
+	async orThrow(factory) {
+		const result = await this.#promise;
+		if (result.ok) return result.data;
+		const mapper = factory ?? throwMappers.get(this);
+		throw mapper ? mapper(result.error) : new DbException(result.error);
+	}
+	/** Resolves with the data, or `fallback` when the result is an error. */
+	async unwrapOr(fallback) {
+		const result = await this.#promise;
+		return result.ok ? result.data : fallback;
+	}
+	map(fn) {
+		return inherit(this, new AsyncResult(this.#promise.then((result) => result.ok ? ok(fn(result.data)) : result)));
+	}
+	mapError(fn) {
+		return inherit(this, new AsyncResult(this.#promise.then((result) => result.ok ? result : err(fn(result.error)))));
+	}
+	andThen(fn) {
+		return inherit(this, new AsyncResult(this.#promise.then((result) => result.ok ? fn(result.data) : result)));
+	}
+};
+function toBetterResult(result, api, mapError) {
+	const build = (settled, mapper) => settled.ok ? api.ok(settled.data) : api.err(mapper ? mapper(settled.error) : settled.error);
+	if (result instanceof AsyncResult) {
+		const mapper = mapError ?? throwMappers.get(result);
+		return result.then((settled) => build(settled, mapper));
+	}
+	return build(result, mapError);
+}
+/**
+* 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`).
+*/
+function fromBetterResult(result, mapError = toDbError) {
+	switch (result.status) {
+		case "ok": return ok(result.value);
+		case "error": return err(dbErrorOf(result.error) ?? mapError(result.error));
+		default: throw new TypeError(`better-supabase: fromBetterResult() expects a better-result value, got ${String(result)}`);
+	}
+}
+function toDbError(cause) {
+	if (cause instanceof DbException) return cause.error;
+	if (cause instanceof Error && cause.name === "AbortError") return dbError("aborted", cause.message || "The operation was aborted");
+	const message = cause instanceof Error ? cause.message : String(cause);
+	return dbError("unexpected", message);
+}
+//#endregion
+export { toBetterResult as a, ok as i, err as n, toDbError as o, fromBetterResult as r, withErrorMapper as s, AsyncResult as t };

package/dist/scope-CDHcS7dE.js

@@ -0,0 +1,90 @@
+import { r as not, t as and } from "./types-6cYK9pbJ.js";
+//#region src/ir/scope.ts
+/**
+* Applies `scopeFor` to every relation filter in a condition. `every(W)`
+* becomes `none(S and not W)` so out-of-scope rows (soft-deleted, other
+* tenants) neither satisfy nor fail it.
+*/
+function scopeCondition(condition, scopeFor) {
+	if (!condition) return void 0;
+	switch (condition.kind) {
+		case "and":
+		case "or": return {
+			kind: condition.kind,
+			items: condition.items.map((item) => scopeCondition(item, scopeFor) ?? item)
+		};
+		case "not": return {
+			kind: "not",
+			item: scopeCondition(condition.item, scopeFor) ?? condition.item
+		};
+		case "column": return condition;
+		case "relation": {
+			const inner = scopeCondition(condition.where, scopeFor);
+			const scope = scopeFor(condition.target);
+			if (!scope) return {
+				...condition,
+				where: inner
+			};
+			switch (condition.quantifier) {
+				case "some":
+				case "none": return {
+					...condition,
+					where: and(inner, scope)
+				};
+				case "every": return inner ? {
+					...condition,
+					quantifier: "none",
+					where: and(scope, not(inner))
+				} : {
+					...condition,
+					where: void 0
+				};
+				default: return condition.quantifier;
+			}
+		}
+		default: return condition;
+	}
+}
+function scopeInclude(include, scopeFor) {
+	return {
+		...include,
+		selection: scopeSelection(include.selection, scopeFor),
+		where: and(scopeCondition(include.where, scopeFor), scopeFor(include.target))
+	};
+}
+/** Applies `scopeFor` to every include and to filters inside includes. */
+function scopeSelection(selection, scopeFor) {
+	if (selection.includes.length === 0) return selection;
+	return {
+		...selection,
+		includes: selection.includes.map((include) => scopeInclude(include, scopeFor))
+	};
+}
+/**
+* Scopes a whole operation: the root table's rows (reads, updates, deletes),
+* relation filters, includes and returned embeds. Inserts only get their
+* returning selection scoped.
+*/
+function scopeOperation(op, scopeFor, root = true) {
+	const own = root ? scopeFor(op.table) : void 0;
+	switch (op.kind) {
+		case "select": return {
+			...op,
+			selection: scopeSelection(op.selection, scopeFor),
+			where: and(scopeCondition(op.where, scopeFor), own)
+		};
+		case "update":
+		case "delete": return {
+			...op,
+			where: and(scopeCondition(op.where, scopeFor), own),
+			returning: op.returning ? scopeSelection(op.returning, scopeFor) : void 0
+		};
+		case "insert": return {
+			...op,
+			returning: op.returning ? scopeSelection(op.returning, scopeFor) : void 0
+		};
+		default: return op;
+	}
+}
+//#endregion
+export { scopeOperation as n, scopeSelection as r, scopeCondition as t };

package/dist/seed-CzecODcJ.js

@@ -0,0 +1,101 @@
+//#region src/testing/seed.ts
+const SEED = Symbol.for("better-supabase.seed");
+function isSeed(value) {
+	return typeof value === "object" && value !== null && SEED in value;
+}
+const quote = (text) => `'${text.replaceAll("'", "''")}'`;
+function arrayLiteral(values) {
+	return `{${values.map((value) => {
+		if (value === null) return "NULL";
+		if (Array.isArray(value)) return arrayLiteral(value);
+		return `"${(value instanceof Date ? value.toISOString() : String(value)).replace(/[\\"]/g, "\\$&")}"`;
+	}).join(",")}}`;
+}
+function literal(value, column, where) {
+	if (value === null) return "null";
+	if (column.json) return quote(JSON.stringify(value));
+	if (Array.isArray(value)) return quote(arrayLiteral(value));
+	if (value instanceof Date) return quote(value.toISOString());
+	const kind = typeof value;
+	switch (kind) {
+		case "string": return quote(value);
+		case "boolean":
+		case "bigint": return String(value);
+		case "number":
+			if (!Number.isFinite(value)) throw new TypeError(`${where}: ${String(value)} is not a finite number`);
+			return String(value);
+		case "object":
+		case "function":
+		case "symbol":
+		case "undefined": throw new TypeError(`${where}: unsupported value of type ${kind}`);
+		default: throw new TypeError(`${where}: unsupported value of type ${String(kind)}`);
+	}
+}
+const ident = (name) => `"${name.replaceAll("\"", "\"\"")}"`;
+/** Parents first (by forward relations), otherwise in the order given. */
+function order(meta, keys) {
+	const sorted = [];
+	const visiting = /* @__PURE__ */ new Set();
+	const visit = (key) => {
+		if (sorted.includes(key) || visiting.has(key)) return;
+		visiting.add(key);
+		for (const relation of Object.values(meta.tables[key]?.relations ?? {})) if (relation.direction === "forward" && relation.table !== key && keys.includes(relation.table)) visit(relation.table);
+		visiting.delete(key);
+		sorted.push(key);
+	};
+	for (const key of keys) visit(key);
+	return sorted;
+}
+function statement(table, rows) {
+	const entries = Object.entries(rows);
+	if (entries.length === 0) return void 0;
+	const columns = [];
+	for (const [, row] of entries) for (const [key, value] of Object.entries(row)) {
+		if (value === void 0 || columns.includes(key)) continue;
+		const column = table.columns[key];
+		if (!column) throw new TypeError(`seed ${table.key}: unknown column "${key}"`);
+		if (column.generated) throw new TypeError(`seed ${table.key}: "${key}" is a generated column`);
+		columns.push(key);
+	}
+	const values = entries.map(([name, row]) => {
+		return `  (${columns.map((key) => row[key] === void 0 ? "default" : literal(row[key], table.columns[key], `seed ${table.key}.${name}.${key}`)).join(", ")})`;
+	});
+	return `insert into ${`${ident(table.schema)}.${ident(table.name)}`} (${columns.map((key) => ident(table.columns[key].db)).join(", ")}) values\n${values.join(",\n")}\non conflict do nothing;`;
+}
+/**
+* Typed fixtures shared by `supabase/seeds` and your tests. Rows use app
+* casing and Insert types; `better-supabase seed` renders them to SQL.
+*
+* ```ts
+* export const seed = defineSeed(sb, {
+*   organizations: { acme: { id: ACME, name: 'Acme' } },
+*   customers: { first: { organizationId: ACME, name: 'First customer' } },
+* });
+* ```
+*/
+function defineSeed(sb, fixtures) {
+	const meta = sb.meta;
+	const statements = () => {
+		const keys = Object.keys(fixtures).filter((key) => fixtures[key] !== void 0);
+		for (const key of keys) {
+			const table = meta.tables[key];
+			if (!table) throw new TypeError(`seed: unknown table "${key}"`);
+			if (table.kind === "view") throw new TypeError(`seed: "${key}" is a view`);
+		}
+		return order(meta, keys).flatMap((key) => {
+			const sql = statement(meta.tables[key], fixtures[key]);
+			return sql ? [sql] : [];
+		});
+	};
+	return {
+		[SEED]: true,
+		rows: fixtures,
+		statements,
+		sql: () => statements().join("\n\n"),
+		async insert(sql) {
+			for (const text of statements()) await sql.queryRaw(text);
+		}
+	};
+}
+//#endregion
+export { isSeed as n, defineSeed as t };