better-supabase 0.0.0 → 0.1.0

package/dist/index-Nxo3TJcm.d.ts

@@ -0,0 +1,208 @@
+import { p as DbError, t as AsyncResult } from "./result-CTkCZ6JA.js";
+import { n as StoragePath, t as PathIn } from "./path-Cv__-OTj.js";
+import { n as TemplateValues, t as TemplateParams } from "./template-mbvlysOo.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+//#region src/storage/index.d.ts
+type BucketPolicy = "tenant" | "owner" | "public" | "none";
+interface BucketConfig<P extends string = string, Id extends string = string> {
+  /** Bucket id, e.g. `customer-logos`. */
+  readonly id: Id;
+  /** Object path template, e.g. `{orgId}/{customerId}/logo/{version}.webp`. */
+  readonly path: P;
+  readonly public?: boolean;
+  /**
+   * Generated `storage.objects` policies. `tenant` and `owner` match a path
+   * segment against the JWT; `public` allows reads; `none` leaves access to
+   * the secret key. Defaults to `none`.
+   */
+  readonly policy?: BucketPolicy;
+  /** `'5MiB'`, `'500KB'` or bytes. */
+  readonly fileSizeLimit?: string | number;
+  /** `['image/png', 'image/*']`. */
+  readonly allowedMimeTypes?: readonly string[];
+  readonly tenant?: {
+    /** Placeholder holding the tenant id. Defaults to `orgId`. */
+    readonly param?: string;
+    /** JWT claim paths, first match wins. Defaults to `org_id`, then `app_metadata.org_id`. */
+    readonly claim?: string | readonly string[];
+    /** SQL expression for the tenant id, instead of `claim`. */
+    readonly sql?: string;
+  };
+  readonly owner?: {
+    /** Placeholder holding the user id. Defaults to `userId`. */
+    readonly param?: string;
+  };
+}
+/**
+ * A path from the template's values, or an existing path string (checked
+ * against the template). `StoragePath`s of other buckets are rejected.
+ */
+type ObjectTarget<P extends string, Id extends string = string> = TemplateValues<P> | PathIn<Id>;
+declare const TTL: {
+  readonly minute: 60;
+  readonly hour: 3600;
+  readonly day: 86_400;
+  readonly week: 604_800;
+};
+type TtlPreset = keyof typeof TTL;
+interface TransformOptions {
+  readonly width?: number;
+  readonly height?: number;
+  readonly resize?: "cover" | "contain" | "fill";
+  readonly quality?: number;
+  readonly format?: "origin";
+}
+type UploadBody = Blob | ArrayBuffer | ArrayBufferView | ReadableStream<Uint8Array> | FormData | string;
+interface UploadOptions {
+  readonly contentType?: string;
+  readonly cacheControl?: string;
+  readonly upsert?: boolean;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  readonly signal?: AbortSignal;
+}
+interface UrlOptions {
+  /** Seconds or a preset. Defaults to `hour`. */
+  readonly ttl?: number | TtlPreset;
+  readonly transform?: TransformOptions;
+  /** Serve as an attachment, optionally with a file name. */
+  readonly download?: boolean | string;
+}
+interface StoredObject {
+  readonly path: string;
+  readonly size?: number;
+  readonly contentType?: string;
+  readonly createdAt: string | null;
+  readonly updatedAt: string | null;
+}
+interface Reservation {
+  readonly path: string;
+  readonly token: string;
+  readonly signedUrl: string;
+}
+interface ReplaceOptions<Id extends string = string> extends UploadOptions {
+  /** Path the object replaces. Removed after `commit` succeeds. */
+  readonly previous?: string | null;
+  /**
+   * Store the new path, e.g. update the row. Throwing or returning an error
+   * `Result` removes the new object and keeps the previous one.
+   */
+  readonly commit?: (path: StoragePath<Id>) => unknown;
+}
+interface ReplaceResult<Id extends string = string> {
+  readonly path: StoragePath<Id>;
+  readonly removed: string | null;
+  /** Set when the previous object could not be removed. */
+  readonly cleanup?: DbError;
+}
+interface SweepOptions<P extends string> {
+  /** Only look under the path prefix these values fill. */
+  readonly within?: Partial<TemplateValues<P>>;
+  /** Minimum age in milliseconds, or a cutoff date. */
+  readonly olderThan: number | Date;
+  /** Returns which of `paths` are still referenced. */
+  readonly referenced: (paths: readonly string[]) => PromiseLike<Iterable<string>> | Iterable<string>;
+  readonly dryRun?: boolean;
+  readonly batchSize?: number;
+  readonly signal?: AbortSignal;
+  readonly now?: () => number;
+}
+interface SweepResult {
+  readonly scanned: number;
+  readonly orphans: readonly string[];
+  readonly removed: readonly string[];
+}
+interface BucketDrift {
+  readonly field: "missing" | "public" | "fileSizeLimit" | "allowedMimeTypes";
+  readonly expected: unknown;
+  readonly actual: unknown;
+  readonly message: string;
+}
+/** Bucket state as stored in `storage.buckets` (or `better-supabase` introspection). */
+interface ActualBucket {
+  readonly public: boolean;
+  readonly fileSizeLimit?: number | null;
+  readonly allowedMimeTypes?: readonly string[] | null;
+}
+type StorageClient = Pick<SupabaseClient, "storage">;
+interface BucketClient<P extends string, Id extends string = string> {
+  readonly bucket: Bucket<P, Id>;
+  upload(target: ObjectTarget<P, Id>, body: UploadBody, options?: UploadOptions): AsyncResult<{
+    path: StoragePath<Id>;
+  }>;
+  download(target: ObjectTarget<P, Id>, options?: {
+    signal?: AbortSignal;
+  }): AsyncResult<Blob>;
+  exists(target: ObjectTarget<P, Id>): AsyncResult<boolean>;
+  remove(targets: readonly ObjectTarget<P, Id>[]): AsyncResult<readonly string[]>;
+  list(within?: Partial<TemplateValues<P>>, options?: {
+    signal?: AbortSignal;
+  }): AsyncResult<readonly StoredObject[]>;
+  signedUrl(target: ObjectTarget<P, Id>, options?: UrlOptions): AsyncResult<string>;
+  signedUrls(targets: readonly ObjectTarget<P, Id>[], options?: Omit<UrlOptions, "transform">): AsyncResult<readonly string[]>;
+  /** URL for public buckets. No request is made. */
+  publicUrl(target: ObjectTarget<P, Id>, options?: Omit<UrlOptions, "ttl">): string;
+  /** Image transform URL: public for public buckets, signed otherwise. */
+  renderUrl(target: ObjectTarget<P, Id>, transform: TransformOptions, options?: Omit<UrlOptions, "transform">): AsyncResult<string>;
+  /** Upload the new object, run `commit`, then remove the previous object. */
+  replace(target: ObjectTarget<P, Id>, body: UploadBody, options?: ReplaceOptions<Id>): AsyncResult<ReplaceResult<Id>>;
+  /** A signed upload URL for a browser or another service. */
+  reserve(target: ObjectTarget<P, Id>, options?: {
+    upsert?: boolean;
+  }): AsyncResult<Reservation>;
+  uploadReserved(reservation: Pick<Reservation, "path" | "token">, body: UploadBody, options?: UploadOptions): AsyncResult<{
+    path: StoragePath<Id>;
+  }>;
+  /** Removes objects that match the template, are old enough and are not referenced. */
+  sweep(options: SweepOptions<P>): AsyncResult<SweepResult>;
+}
+interface Bucket<P extends string, Id extends string = string> {
+  readonly id: Id;
+  readonly template: P;
+  readonly params: readonly TemplateParams<P>[];
+  readonly public: boolean;
+  readonly policy: BucketPolicy;
+  /**
+   * Placeholder holding the owning user's id: `owner.param` for `owner`
+   * buckets, otherwise `userId` when the template has it. Account deletion
+   * removes the objects it fills.
+   */
+  readonly owner: string | undefined;
+  readonly fileSizeLimit: number | undefined;
+  readonly allowedMimeTypes: readonly string[] | undefined;
+  path(values: TemplateValues<P>): StoragePath<Id>;
+  match(path: string): TemplateValues<P> | null;
+  /** Folder prefix filled by `values`, for listing. */
+  prefix(values?: Partial<TemplateValues<P>>): string;
+  /** Checks a size and content type against the bucket limits. */
+  check(file: {
+    size?: number;
+    type?: string;
+  }): DbError | undefined;
+  /** `insert into storage.buckets` plus `storage.objects` policies. Idempotent. */
+  sql(): string;
+  /** A `[storage.buckets.<id>]` section for `supabase/config.toml`. */
+  toml(): string;
+  drift(actual: ActualBucket | undefined): readonly BucketDrift[];
+  connect(client: StorageClient): BucketClient<P, Id>;
+}
+declare function parseSize(value: string | number): number;
+/** Maps a Storage error (`StorageApiError`, fetch failures) to a `DbError`. */
+declare function fromStorageError(raw: unknown, table?: string): DbError;
+/**
+ * A typed Storage bucket: path builders from a template, limits, generated
+ * SQL policies and `config.toml`, and helpers for the multi-step work apps
+ * repeat (replace, signed uploads, orphan cleanup).
+ *
+ * ```ts
+ * export const logos = defineBucket({
+ *   id: 'customer-logos',
+ *   path: '{orgId}/{customerId}/logo/{version}.webp',
+ *   policy: 'tenant',
+ *   fileSizeLimit: '5MiB',
+ *   allowedMimeTypes: ['image/webp'],
+ * });
+ * ```
+ */
+declare function defineBucket<const P extends string, const Id extends string = string>(config: BucketConfig<P, Id>): Bucket<P, Id>;
+//#endregion
+export { parseSize as C, fromStorageError as S, TtlPreset as _, BucketDrift as a, UrlOptions as b, ReplaceOptions as c, StorageClient as d, StoredObject as f, TransformOptions as g, TTL as h, BucketConfig as i, ReplaceResult as l, SweepResult as m, Bucket as n, BucketPolicy as o, SweepOptions as p, BucketClient as r, ObjectTarget as s, ActualBucket as t, Reservation as u, UploadBody as v, defineBucket as x, UploadOptions as y };

package/dist/index-Sw43J8HG.d.ts

@@ -0,0 +1,62 @@
+import { n as AnyModels, t as AnyFunctions } from "./types-C2fslP1z.js";
+import { t as BetterSupabase, y as Db } from "./define-CTfWw-SS.js";
+import { c as PublicEnv } from "./index-Dy6kuF0P.js";
+import { i as Queries } from "./index-Dup-nSe9.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+//#region src/client/index.d.ts
+interface BrowserOptions {
+  /** URL and publishable key. Not needed when `client` is given. */
+  readonly env?: PublicEnv;
+  /** Bring your own supabase-js client (React Native, custom storage). */
+  readonly client?: SupabaseClient;
+  /**
+   * `cookies` (default) shares the session with the server through
+   * `@supabase/ssr`; `local` keeps it in localStorage for SPAs without a server.
+   */
+  readonly storage?: "cookies" | "local";
+}
+interface AuthUser {
+  readonly id: string;
+  readonly email?: string;
+  readonly role?: string;
+}
+/** What the UI needs to know. Claims are decoded, not verified: RLS enforces access. */
+type AuthSnapshot = {
+  readonly status: "loading";
+  readonly user: null;
+  readonly claims: null;
+} | {
+  readonly status: "signed-out";
+  readonly user: null;
+  readonly claims: null;
+} | {
+  readonly status: "signed-in";
+  readonly user: AuthUser;
+  readonly claims: Readonly<Record<string, unknown>>;
+};
+interface BrowserAuth {
+  readonly current: () => AuthSnapshot;
+  /** `useSyncExternalStore`-compatible. */
+  readonly subscribe: (listener: () => void) => () => void;
+}
+interface BetterBrowser<M extends AnyModels, F extends AnyFunctions, E, C = unknown> {
+  /** The definition the browser was created from (schema metadata, specs, live queries). */
+  readonly sb: BetterSupabase<M, unknown, F, E, C>;
+  readonly supabase: SupabaseClient;
+  /** Repositories with the current session's actor and claims. */
+  readonly db: Db<M, F, E, SupabaseClient>;
+  /** TanStack Query option factories over `db`. */
+  readonly queries: Queries<M, E, F>;
+  readonly auth: BrowserAuth;
+}
+/**
+ * The browser side: a supabase-js client, repositories that follow the
+ * session, TanStack Query options and an auth store for UI state.
+ *
+ * ```ts
+ * export const browser = createBrowser(sb, { env: { url, publishableKey } });
+ * ```
+ */
+declare function createBrowser<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown>(sb: BetterSupabase<M, D, F, E, C>, options?: BrowserOptions): BetterBrowser<M, F, E, C>;
+//#endregion
+export { BrowserOptions as a, BrowserAuth as i, AuthUser as n, createBrowser as o, BetterBrowser as r, AuthSnapshot as t };

package/dist/index-cEeweTeM.d.ts

@@ -0,0 +1,38 @@
+import { m as StoredSession } from "./resolve-DW8h9NPm.js";
+import "./view-B0ltUmTi.js";
+import "./entitlements-BBg61DQZ.js";
+//#region src/auth/refresh.d.ts
+interface RefreshOptions {
+  readonly url: string;
+  readonly publishableKey: string;
+  /**
+   * Sends `Sb-Forwarded-For: ip` with the secret key, so Auth rate-limits the
+   * refresh by the user's IP (when IP forwarding is on for the project).
+   */
+  readonly forwardedFor?: {
+    readonly ip: string;
+    readonly secretKey: string;
+  };
+  readonly fetch?: typeof fetch;
+  readonly now?: () => number;
+}
+type RefreshOutcome = {
+  readonly ok: true;
+  readonly session: StoredSession;
+  /** Served from a concurrent or just-finished refresh of the same token. */
+  readonly shared?: boolean;
+} | {
+  readonly ok: false;
+  /** `rejected`: the refresh token is dead, sign the user out. `network`: keep the session and retry later. */
+  readonly reason: "rejected" | "network";
+  readonly status?: number;
+  readonly message: string;
+};
+/**
+ * Exchanges a refresh token for a new session. Concurrent calls with the same
+ * token share one request, and a successful result is reused for a short
+ * window so parallel requests carrying the old cookie converge on one session.
+ */
+declare function refreshSession(refreshToken: string, options: RefreshOptions): Promise<RefreshOutcome>;
+//#endregion
+export { RefreshOutcome as n, refreshSession as r, RefreshOptions as t };

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { A as TableMeta, C as Relations, D as Simplify, E as SchemaMeta, M as UniqueKeyName, N as UniqueWhere, O as TableFlags, P as Update, S as RelationShape, T as Schema, _ as ModelsOf, a as CheckConstraint, b as RealtimeTableMeta, c as DatabaseOf, d as ForeignKeyConstraint, f as FunctionMeta, g as ModelShape, h as Insert, i as Casing, j as UniqueConstraint, k as TableKey, l as Flags, m as FunctionsOf, n as AnyModels, o as Codec, p as FunctionShape, r as BucketMeta, s as ColumnMeta, t as AnyFunctions, u as FlagsShape, v as PrimaryKeyColumn, w as Row, x as RelationMeta, y as PrimaryKeyValue } from "./types-C2fslP1z.js";
+import { C as and, E as or, S as UpdateOp, T as not, _ as OrderTerm, a as AggregateFn, b as SelectOp, c as Condition, d as FunctionSource, f as Include, g as Operation, h as MutationOp, i as RpcContext, l as CountMode, m as Measure, n as ExecuteResult, o as Aggregation, p as InsertOp, r as Executor, s as ColumnOp, t as ExecuteContext, u as DeleteOp, v as Quantifier, w as column, x as Selection, y as SelectColumn } from "./executor-Bazhgsgq.js";
+import { C as isConflict, D as statusOf, E as mapDbError, S as isCheck, T as isForeignKey, _ as DbException, a as Ok, b as ValidationIssue, c as err, d as toBetterResult, f as toDbError, g as DbErrorOf, h as DbErrorKinds, i as Err, l as fromBetterResult, m as DbErrorKind, n as BetterResultApi, o as Result, p as DbError, r as BetterResultShape, t as AsyncResult, u as ok, v as ErrorMapper, w as isDbError, x as dbError, y as RawDbError } from "./result-CTkCZ6JA.js";
+import { a as EventHub, c as QueryEvent, d as LogFields, f as Logger, i as EventHandler, l as RefreshEvent, m as silentLogger, n as BetterSupabaseEvents, o as EventName, p as consoleLogger, r as ErrorEvent, s as MutationNotice, t as AuthEvent, u as RpcNotice } from "./events-2OJsVG_d.js";
+import { $ as Specs, A as RpcOptions, B as ReadSet, C as FindExt, Ct as WhereInput, D as Repository, E as PageOf, F as EMPTY_STATS, G as ReadSetParams, H as ReadSetParamType, I as StatsRecorder, J as isReadSet, K as ReadSetResult, L as recordStats, M as UpsertArgs, N as WriteArgs, O as RepositoryOf, P as DbStats, Q as ReadMethod, R as SearchArgs, S as DeleteExt, St as SortDirection, T as OffsetPageArgs, U as ReadSetParamTypes, V as ReadSetOptions, W as ReadSetParamValue, X as InferResult, Y as readSetTables, Z as QuerySpec, _ as CursorPage, _t as OrderByInput, a as defineSupabase, at as AggregateRow, b as DbHelpers, bt as RelationMeasureArg, c as postgrestExecutor, ct as FieldFilter, d as MemoryCache, dt as IncludeArg, et as TableSpecs, f as cacheTargetOf, ft as IncludeArgs, g as ConflictTarget, gt as OrderByArg, h as rpcCacheTargets, ht as NumericMeasureArg, i as RpcDefinition, it as AggregateResult, j as UpdateArgs, k as Returned, l as CacheAdapter, lt as FindFirstArgs, m as rowKey, mt as MeasureKey, n as ConnectOptions, nt as specTables, o as PostgrestClientLike, ot as CountArg, p as memoryCache, pt as MeasureArg, q as defineReadSet, r as DefineSupabaseOptions, rt as AggregateArgs, s as explainPostgrest, st as CountArgs, t as BetterSupabase, tt as isQuerySpec, u as CacheTarget, ut as FindManyArgs, v as CursorPageArgs, vt as Payload, w as OffsetPage, x as DeleteArgs, xt as SelectArg, y as Db, yt as ReadArgs, z as InferReadSetParams } from "./define-CTfWw-SS.js";
+import { _ as definePlugin, a as ExtensionOf, c as MutationEvent, d as PLUGIN_API_VERSION, f as Plugin, g as WithExtension, h as RequestContext, i as CallOptions, l as MutationKind, m as RepositoryExtension, n as AnyPlugin, o as HasFlag, p as RepositoryApi, r as ApplyExtension, s as HookArgs, t as Actor, u as NoExtension } from "./plugin-HvGqCurB.js";
+import { n as validate, t as StandardSchemaV1 } from "./standard-CyhRzctb.js";
+import { a as compilePostgrest, i as PostgrestPlan, n as PlanLimit, r as PlanOrder, t as PlanFilter } from "./postgrest-Dm-vhY6R.js";
+import { n as StoragePath } from "./path-Cv__-OTj.js";
+import { n as postgrestCompiler, t as Compiler } from "./compiler-DL18ukPe.js";
+import { a as ProblemResponseOptions, c as problemResponse, i as ProblemOptions, l as toProblem, n as PROBLEM_TYPE_BASE, o as fromProblem, r as ProblemDetails, s as isProblem, t as PROBLEM_CONTENT_TYPE } from "./problem-DlgB0lYl.js";
+import { t as SPEC_PINS } from "./spec-pins-CJPVghHy.js";
+//#region src/core/define-repository.d.ts
+/** Adds `Methods` to the repository of `Table` only. */
+interface TableRepositoryExtension<Table extends string, Methods> extends RepositoryExtension {
+  readonly methods: this["T"] extends Table ? Methods : unknown;
+}
+/**
+ * Domain methods for one table, installed with `use()`. `base` is the
+ * repository at call time, with every other plugin's methods.
+ *
+ * ```ts
+ * const customers = defineRepository(sb, 'customers', (base) => ({
+ *   active: () => base.findMany({ where: { status: 'active' } }),
+ * }));
+ * export const app = sb.use(customers);
+ * await app.connect(client).customers.active();
+ * ```
+ */
+export declare function defineRepository<M extends AnyModels, D, F extends AnyFunctions, E, const Table extends TableKey<M>, Methods extends object>(sb: BetterSupabase<M, D, F, E>, table: Table, build: (base: RepositoryOf<M, Table, E>) => Methods): Plugin<`repository:${Table}`, TableRepositoryExtension<Table, Methods>>;
+//#endregion
+//#region src/ir/tables.d.ts
+/**
+ * App keys of every table an operation reads or writes: its own table, each
+ * included relation and each relation used in a filter. Cached reads of these
+ * tables go stale when any of them changes.
+ */
+export declare function touchedTables(op: Operation): string[];
+/**
+ * Tables whose rows can change when rows of `table` change: the table itself
+ * plus every table whose foreign key cascades or sets a value on delete,
+ * followed through chains of cascades.
+ */
+export declare function invalidationTargets(meta: SchemaMeta, table: string): string[];
+//#endregion
+//#region src/core/cursor.d.ts
+/** Opaque, URL-safe keyset cursor. */
+export declare function encodeCursor(values: readonly unknown[]): string;
+export declare function decodeCursor(cursor: string): unknown[] | undefined;
+//#endregion
+//#region src/schema/define.d.ts
+/**
+ * Binds generated model types to runtime metadata. Called from the generated
+ * module; apps import the returned `schema`, never call this themselves.
+ */
+export declare function defineSchema<M extends AnyModels, D = unknown, F extends AnyFunctions = AnyFunctions>(meta: SchemaMeta): Schema<M, D, F>;
+export declare function tableMeta(meta: SchemaMeta, table: string): TableMeta;
+//#endregion
+//#region src/schema/enrich.d.ts
+type Override<R, O> = { [K in keyof R]: K extends keyof O ? null extends R[K] ? O[K] | null : O[K] : R[K]; };
+type EnrichTables<Tables, O> = { [T in keyof Tables]: T extends keyof O ? { [P in keyof Tables[T]]: P extends "Row" | "Insert" | "Update" ? Override<Tables[T][P], O[T]> : Tables[T][P]; } : Tables[T]; };
+type EnrichSchema<S, O> = { [P in keyof S]: P extends "Tables" | "Views" ? EnrichTables<S[P], O> : S[P]; };
+/**
+ * Narrows column types of a `supabase gen types` `Database`: CHECK-constraint
+ * unions and typed jsonb. Overrides are keyed `{ schema: { table: { column } } }`.
+ */
+type EnrichDatabase<D, O> = { [S in keyof D]: S extends keyof O ? EnrichSchema<D[S], O[S]> : D[S]; };
+//#endregion
+//#region src/ir/build.d.ts
+/** Escapes LIKE wildcards so user input matches literally. */
+export declare function escapeLike(value: string): string;
+//#endregion
+//#region src/ir/codec.d.ts
+/** Wire form of an app value: `Date` to ISO text, `bigint` to decimal text. */
+export declare function encodeValue(value: unknown): unknown;
+/** Applies column codecs to returned rows, including embedded relations. */
+export declare function decodeRows(selection: Selection | undefined, rows: readonly Record<string, unknown>[]): Record<string, unknown>[];
+//#endregion
+//#region src/ir/scope.d.ts
+/** Returns the filter that always applies to rows of `table`, if any. */
+type ScopeFor = (table: TableMeta) => Condition | undefined;
+/**
+ * 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.
+ */
+export declare function scopeCondition(condition: Condition | undefined, scopeFor: ScopeFor): Condition | undefined;
+/** Applies `scopeFor` to every include and to filters inside includes. */
+export declare function scopeSelection(selection: Selection, scopeFor: ScopeFor): Selection;
+/**
+ * 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.
+ */
+export declare function scopeOperation(op: Operation, scopeFor: ScopeFor, root?: boolean): Operation;
+//#endregion
+//#region src/ir/simplify.d.ts
+/**
+ * Folds constant conditions. `true` means "no filter", `false` means "matches
+ * nothing", so executors can skip the request entirely.
+ */
+export declare function simplify(condition: Condition | undefined): Condition | boolean;
+//#endregion
+//#region src/casing/index.d.ts
+/** `first_name` to `firstName`. Leaves already camel-cased names untouched. */
+export declare function toCamel(name: string): string;
+/** `firstName` to `first_name`. */
+export declare function toSnake(name: string): string;
+//#endregion
+export { type Actor, type AggregateArgs, type AggregateFn, type AggregateResult, type AggregateRow, type Aggregation, type AnyFunctions, type AnyModels, type AnyPlugin, type ApplyExtension, AsyncResult, type AuthEvent, type BetterResultApi, type BetterResultShape, BetterSupabase, type BetterSupabaseEvents, type BucketMeta, type CacheAdapter, type CacheTarget, type CallOptions, type Casing, type CheckConstraint, type Codec, type ColumnMeta, type ColumnOp, type Compiler, type Condition, type ConflictTarget, type ConnectOptions, type CountArg, type CountArgs, type CountMode, type CursorPage, type CursorPageArgs, type DatabaseOf, type Db, type DbError, type DbErrorKind, type DbErrorKinds, type DbErrorOf, DbException, type DbHelpers, type DbStats, type DefineSupabaseOptions, type DeleteArgs, type DeleteExt, type DeleteOp, EMPTY_STATS, type EnrichDatabase, type Err, type ErrorEvent, type ErrorMapper, type EventHandler, EventHub, type EventName, type ExecuteContext, type ExecuteResult, type Executor, type ExtensionOf, type FieldFilter, type FindExt, type FindFirstArgs, type FindManyArgs, type Flags, type FlagsShape, type ForeignKeyConstraint, type FunctionMeta, type FunctionShape, type FunctionSource, type FunctionsOf, type HasFlag, type HookArgs, type Include, type IncludeArg, type IncludeArgs, type InferReadSetParams, type InferResult, type Insert, type InsertOp, type LogFields, type Logger, type Measure, type MeasureArg, type MeasureKey, type MemoryCache, type ModelShape, type ModelsOf, type MutationEvent, type MutationKind, type MutationNotice, type MutationOp, type NoExtension, type NumericMeasureArg, type OffsetPage, type OffsetPageArgs, type Ok, type Operation, type OrderByArg, type OrderByInput, type OrderTerm, PLUGIN_API_VERSION, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, type PageOf, type Payload, type PlanFilter, type PlanLimit, type PlanOrder, type Plugin, type PostgrestClientLike, type PostgrestPlan, type PrimaryKeyColumn, type PrimaryKeyValue, type ProblemDetails, type ProblemOptions, type ProblemResponseOptions, type Quantifier, type QueryEvent, type QuerySpec, type RawDbError, type ReadArgs, type ReadMethod, type ReadSet, type ReadSetOptions, type ReadSetParamType, type ReadSetParamTypes, type ReadSetParamValue, type ReadSetParams, type ReadSetResult, type RealtimeTableMeta, type RefreshEvent, type RelationMeasureArg, type RelationMeta, type RelationShape, type Relations, type Repository, type RepositoryApi, type RepositoryExtension, type RepositoryOf, type RequestContext, type Result, type Returned, type Row, type RpcContext, type RpcDefinition, type RpcNotice, type RpcOptions, SPEC_PINS, type Schema, type SchemaMeta, type ScopeFor, type SearchArgs, type SelectArg, type SelectColumn, type SelectOp, type Selection, type Simplify, type SortDirection, type Specs, type StandardSchemaV1, StatsRecorder, type StoragePath, type TableFlags, type TableKey, type TableMeta, type TableRepositoryExtension, type TableSpecs, type UniqueConstraint, type UniqueKeyName, type UniqueWhere, type Update, type UpdateArgs, type UpdateOp, type UpsertArgs, type ValidationIssue, type WhereInput, type WithExtension, type WriteArgs, and, cacheTargetOf, column, compilePostgrest, consoleLogger, dbError, definePlugin, defineReadSet, defineSupabase, err, explainPostgrest, fromBetterResult, fromProblem, isCheck, isConflict, isDbError, isForeignKey, isProblem, isQuerySpec, isReadSet, mapDbError, memoryCache, not, ok, or, postgrestCompiler, postgrestExecutor, problemResponse, readSetTables, recordStats, rowKey, rpcCacheTargets, silentLogger, specTables, statusOf, toBetterResult, toDbError, toProblem, validate };

package/dist/index.js

@@ -0,0 +1,42 @@
+import { a as isConflict, c as mapDbError, i as isCheck, l as statusOf, n as dbError, o as isDbError, s as isForeignKey, t as DbException } from "./errors-Bl3rkOzo.js";
+import { i as escapeLike, l as defineSchema, o as decodeRows, s as encodeValue, t as simplify, u as tableMeta } from "./simplify-oHiDKRVQ.js";
+import { i as or, n as column, r as not, t as and } from "./types-6cYK9pbJ.js";
+import { a as toBetterResult, i as ok, n as err, o as toDbError, r as fromBetterResult, t as AsyncResult } from "./result-DWXatkd6.js";
+import { a as EventHub, c as cacheTargetOf, d as rpcCacheTargets, i as encodeCursor, l as memoryCache, n as defineSupabase, o as consoleLogger, r as decodeCursor, s as silentLogger, t as BetterSupabase, u as rowKey } from "./define-QGkq04oe.js";
+import { n as touchedTables, t as invalidationTargets } from "./tables-rZxRxNPW.js";
+import { n as definePlugin, t as PLUGIN_API_VERSION } from "./plugin-BqR6wKMB.js";
+import { a as postgrestExecutor, i as explainPostgrest, n as StatsRecorder, o as compilePostgrest, r as recordStats, t as EMPTY_STATS } from "./stats-3iy8u3_P.js";
+import { c as readSetTables, d as isQuerySpec, f as specTables, i as defineReadSet, o as isReadSet } from "./read-set-DhX2d04c.js";
+import { t as validate } from "./standard-FUi3Z3-7.js";
+import { a as problemResponse, i as isProblem, n as PROBLEM_TYPE_BASE, o as toProblem, r as fromProblem, t as PROBLEM_CONTENT_TYPE } from "./problem-DPu6Fh-t.js";
+import { t as SPEC_PINS } from "./spec-pins-t6sPaHvl.js";
+import { n as scopeOperation, r as scopeSelection, t as scopeCondition } from "./scope-CDHcS7dE.js";
+import { n as toCamel, r as toSnake } from "./casing-da0uRTqt.js";
+//#region src/core/define-repository.ts
+/**
+* Domain methods for one table, installed with `use()`. `base` is the
+* repository at call time, with every other plugin's methods.
+*
+* ```ts
+* const customers = defineRepository(sb, 'customers', (base) => ({
+*   active: () => base.findMany({ where: { status: 'active' } }),
+* }));
+* export const app = sb.use(customers);
+* await app.connect(client).customers.active();
+* ```
+*/
+function defineRepository(sb, table, build) {
+	if (!(table in sb.meta.tables)) throw new TypeError(`better-supabase: defineRepository: unknown table "${table}"`);
+	return definePlugin({
+		name: `repository:${table}`,
+		repository: ({ table: meta, base }) => meta.key === table ? build(base) : void 0
+	});
+}
+//#endregion
+//#region src/core/compiler.ts
+const postgrestCompiler = {
+	target: "postgrest",
+	compile: compilePostgrest
+};
+//#endregion
+export { AsyncResult, BetterSupabase, DbException, EMPTY_STATS, EventHub, PLUGIN_API_VERSION, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, SPEC_PINS, StatsRecorder, and, cacheTargetOf, column, compilePostgrest, consoleLogger, dbError, decodeCursor, decodeRows, definePlugin, defineReadSet, defineRepository, defineSchema, defineSupabase, encodeCursor, encodeValue, err, escapeLike, explainPostgrest, fromBetterResult, fromProblem, invalidationTargets, isCheck, isConflict, isDbError, isForeignKey, isProblem, isQuerySpec, isReadSet, mapDbError, memoryCache, not, ok, or, postgrestCompiler, postgrestExecutor, problemResponse, readSetTables, recordStats, rowKey, rpcCacheTargets, scopeCondition, scopeOperation, scopeSelection, silentLogger, simplify, specTables, statusOf, tableMeta, toBetterResult, toCamel, toDbError, toProblem, toSnake, touchedTables, validate };

package/dist/invalidate-DbxuL2jL.js

@@ -0,0 +1,18 @@
+//#region src/query/invalidate.ts
+function queryTables(query) {
+	const tables = query.meta?.["bsTables"];
+	if (Array.isArray(tables)) return tables.filter((t) => typeof t === "string");
+	const [prefix, table] = query.queryKey;
+	return prefix === "bs" && typeof table === "string" ? [table] : void 0;
+}
+/**
+* Invalidates every query that read one of `tables`: better-supabase queries
+* by their `meta.bsTables`, and other `['bs', table, ...]` keys by prefix.
+*/
+function invalidateTables(client, tables) {
+	if (tables.length === 0) return Promise.resolve();
+	const changed = new Set(tables);
+	return client.invalidateQueries({ predicate: (query) => queryTables(query)?.some((table) => changed.has(table)) ?? false });
+}
+//#endregion
+export { invalidateTables as t };