better-supabase 0.0.0 → 0.2.0

package/dist/index-DuP14VHo.d.ts

@@ -0,0 +1,216 @@
+import { b as PermdockBucketPolicy, i as BucketPolicyName } from "./types-C83v5SQz.js";
+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 = BucketPolicyName | PermdockBucketPolicy;
+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; `{ permdock, scope }` calls PermDock's SQL helpers.
+   * Defaults to `none`.
+   *
+   * The helpers check role and scope only. Use `permdock` just for
+   * permissions whose grants have no row conditions beyond the scope: for a
+   * permission with row conditions (e.g. `ownerId = principal.id`) the bucket
+   * grants every object in the scope. Leave those to the policies
+   * `permdock rls generate` writes.
+   */
+  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 `tenant_id`, then `app_metadata.tenant_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-Dy6kuF0P.d.ts

@@ -0,0 +1,71 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { SupabaseEnv } from "@supabase/server";
+//#region src/env/index.d.ts
+/** Validated Supabase settings. Only `publicEnv()` of it is safe to ship to a browser. */
+interface BetterSupabaseEnv {
+  readonly url: string;
+  readonly publishableKey: string;
+  readonly secretKey?: string;
+  /** Named secret keys from `SUPABASE_SECRET_KEYS`, including `default` when `secretKey` is set. */
+  readonly secretKeys?: Readonly<Record<string, string>>;
+  /** `SUPABASE_JWKS_URL`, or `<url>/auth/v1/.well-known/jwks.json`. */
+  readonly jwksUrl: URL;
+  /** Direct Postgres connection string (`SUPABASE_DB_URL` / `DATABASE_URL`). */
+  readonly dbUrl?: string;
+  /** Project ref for hosted projects (`<ref>.supabase.co`). */
+  readonly projectRef?: string;
+  /** `SUPABASE_READ_URL`: a read replica or the `<ref>-all` load balancer, for reads. */
+  readonly readUrl?: string;
+}
+interface PublicEnv {
+  readonly url: string;
+  readonly publishableKey: string;
+}
+type EnvSource = Readonly<Record<string, string | undefined>>;
+interface EnvIssue {
+  /** The variable names that were checked, first one preferred. */
+  readonly variables: readonly string[];
+  readonly message: string;
+}
+interface EnvOptions {
+  /** Settings that must be present. `url` and `publishableKey` always are. */
+  readonly require?: readonly ("secretKey" | "dbUrl")[];
+}
+type EnvResult = {
+  readonly ok: true;
+  readonly env: BetterSupabaseEnv;
+  readonly issues?: undefined;
+} | {
+  readonly ok: false;
+  readonly env?: undefined;
+  readonly issues: readonly EnvIssue[];
+};
+declare const ENV_VARIABLES: {
+  readonly url: readonly string[];
+  readonly publishableKey: readonly string[];
+  readonly secretKey: readonly string[];
+  readonly dbUrl: readonly string[];
+  readonly jwksUrl: readonly string[];
+  readonly readUrl: readonly string[];
+};
+declare class EnvValidationError extends Error {
+  override readonly name = "EnvValidationError";
+  readonly issues: readonly EnvIssue[];
+  constructor(issues: readonly EnvIssue[]);
+}
+/**
+ * Reads and validates Supabase settings. Accepts the `SUPABASE_`,
+ * `NEXT_PUBLIC_`, `VITE_`, `PUBLIC_`, `EXPO_PUBLIC_` and `NUXT_PUBLIC_`
+ * spellings. Issues name variables, never values.
+ */
+declare function parseEnv(source: EnvSource, options?: EnvOptions): EnvResult;
+/** Like `parseEnv`, but throws `EnvValidationError`. Reads `process.env` by default. */
+declare function loadEnv(source?: EnvSource, options?: EnvOptions): BetterSupabaseEnv;
+/** The env validator as a Standard Schema, for t3-env, framework config or any validator slot. */
+declare function envSchema(options?: EnvOptions): StandardSchemaV1<EnvSource, BetterSupabaseEnv>;
+/** The parts that are safe in client bundles. */
+declare function publicEnv(env: BetterSupabaseEnv): PublicEnv;
+/** Converts to `@supabase/server`'s `SupabaseEnv` (the `env` option of `withSupabase`). */
+declare function toServerEnv(env: BetterSupabaseEnv): SupabaseEnv;
+//#endregion
+export { EnvResult as a, PublicEnv as c, parseEnv as d, publicEnv as f, EnvOptions as i, envSchema as l, ENV_VARIABLES as n, EnvSource as o, toServerEnv as p, EnvIssue as r, EnvValidationError as s, BetterSupabaseEnv as t, loadEnv as u };

package/dist/index-K-3WM2Hp.d.ts

@@ -0,0 +1,117 @@
+import { C as PrimaryKeyValue, L as UniqueWhere, N as TableKey, R as Update, _ as Insert, n as AnyModels, t as AnyFunctions } from "./types-C83v5SQz.js";
+import { _ as DbException } from "./result-CTkCZ6JA.js";
+import { C as FindExt, Ct as WhereInput, M as UpsertArgs, N as WriteArgs, S as DeleteExt, T as OffsetPageArgs, X as InferResult, Z as QuerySpec, _ as CursorPage, it as AggregateResult, j as UpdateArgs, k as Returned, l as CacheAdapter, lt as FindFirstArgs, rt as AggregateArgs, st as CountArgs, t as BetterSupabase, ut as FindManyArgs, v as CursorPageArgs, vt as Payload, w as OffsetPage, x as DeleteArgs, y as Db, yt as ReadArgs } from "./define-e3zI4_4g.js";
+import { DataTag, InfiniteData, QueryClient, SkipToken } from "@tanstack/query-core";
+//#region src/query/invalidate.d.ts
+/** Carried by every better-supabase query: the tables whose changes make it stale. */
+interface BetterQueryMeta {
+  readonly bsTables: readonly string[];
+  readonly [key: string]: unknown;
+}
+/**
+ * Invalidates every query that read one of `tables`: better-supabase queries
+ * by their `meta.bsTables`, and other `['bs', table, ...]` keys by prefix.
+ */
+declare function invalidateTables(client: QueryClient, tables: readonly string[]): Promise<void>;
+//#endregion
+//#region src/query/index.d.ts
+type QueryKeyOf<T> = DataTag<readonly unknown[], T, DbException>;
+type QueryFnOf<T> = ((context: {
+  readonly signal: AbortSignal;
+}) => Promise<T>) | SkipToken;
+/** Options for `useQuery`, `createQuery`, `injectQuery`, `queryClient.fetchQuery` and `prefetchQuery`. */
+interface QueryOptionsOf<T> {
+  readonly queryKey: QueryKeyOf<T>;
+  readonly queryFn: QueryFnOf<T>;
+  readonly meta: BetterQueryMeta;
+  readonly staleTime?: number;
+}
+/** Options for infinite queries over cursor (`string | null`) or offset (`number`) pages. */
+interface InfiniteOptionsOf<P, Param> {
+  readonly queryKey: DataTag<readonly unknown[], InfiniteData<P>, DbException>;
+  readonly queryFn: (context: {
+    readonly signal: AbortSignal;
+    readonly pageParam: Param;
+  }) => Promise<P>;
+  readonly initialPageParam: Param;
+  readonly getNextPageParam: (last: P) => Param | undefined;
+  readonly meta: BetterQueryMeta;
+  readonly staleTime?: number;
+}
+/** Options for `useMutation`. Invalidates every query that read a changed table. */
+interface MutationOptionsOf<V, R> {
+  readonly mutationKey: readonly unknown[];
+  readonly mutationFn: (variables: V) => Promise<R>;
+  readonly onSuccess: (data: R, variables: V, onMutateResult: unknown, context: {
+    readonly client: QueryClient;
+  }) => Promise<void>;
+}
+interface TableQueries<M extends AnyModels, T extends TableKey<M>, E> {
+  /** Prefix of every key for this table's own queries. */
+  readonly key: readonly ["bs", T];
+  findMany<const A extends FindManyArgs<M, T> & FindExt<E, M, T>>(args?: A | SkipToken): QueryOptionsOf<Payload<M, T, A>[]>;
+  findFirst<const A extends FindFirstArgs<M, T> & FindExt<E, M, T>>(args?: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
+  findUnique<const A extends ReadArgs<M, T> & {
+    readonly where: UniqueWhere<M, T>;
+  } & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<Payload<M, T, A> | null>;
+  findById<const A extends ReadArgs<M, T> & FindExt<E, M, T>>(id: PrimaryKeyValue<M, T> | SkipToken, args?: A): QueryOptionsOf<Payload<M, T, A>>;
+  count(args?: (CountArgs<M, T> & FindExt<E, M, T>) | SkipToken): QueryOptionsOf<number>;
+  aggregate<const A extends AggregateArgs<M, T> & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<AggregateResult<M, T, A>>;
+  exists(args?: ({
+    readonly where?: WhereInput<M, T>;
+  } & FindExt<E, M, T>) | SkipToken): QueryOptionsOf<boolean>;
+  paginate<const A extends OffsetPageArgs<M, T> & FindExt<E, M, T>>(args: A | SkipToken): QueryOptionsOf<OffsetPage<Payload<M, T, A>>>;
+  /** Cursor pages for `useInfiniteQuery`. */
+  infinite<const A extends Omit<CursorPageArgs<M, T>, "after"> & FindExt<E, M, T>>(args: A): InfiniteOptionsOf<CursorPage<Payload<M, T, A>>, string | null>;
+  /** Numbered pages for `useInfiniteQuery`, starting at `args.page` (default 1). */
+  infinitePages<const A extends OffsetPageArgs<M, T> & FindExt<E, M, T>>(args: A): InfiniteOptionsOf<OffsetPage<Payload<M, T, A>>, number>;
+  create<const A extends WriteArgs<M, T> = {}>(args?: A): MutationOptionsOf<Insert<M, T>, Returned<M, T, A>>;
+  update<const A extends UpdateArgs<M, T> = {}>(args?: A): MutationOptionsOf<{
+    readonly id: PrimaryKeyValue<M, T>;
+    readonly patch: Update<M, T>;
+  }, Returned<M, T, A>>;
+  upsert<const A extends UpsertArgs<M, T> = {}>(args?: A): MutationOptionsOf<Insert<M, T>, Returned<M, T, A>>;
+  delete(args?: DeleteArgs & DeleteExt<E, M, T>): MutationOptionsOf<PrimaryKeyValue<M, T>, void>;
+}
+type RpcArgsOf<F extends AnyFunctions, N extends keyof F> = F[N]["Args"];
+interface QueryHelpers<M extends AnyModels, F extends AnyFunctions> {
+  /** Prefix of every better-supabase key. */
+  readonly key: readonly ["bs"];
+  /** Query options for a `QuerySpec`, for example one sent from a Server Component. */
+  $spec<S extends QuerySpec<TableKey<M>>>(spec: S | SkipToken): QueryOptionsOf<InferResult<S>>;
+  /** Fetches a spec into `queryClient` for server rendering and hydration. */
+  $prefetch(queryClient: QueryClient, spec: QuerySpec<TableKey<M>>): Promise<void>;
+  /** Query options for a database function. `tables` lists what it reads, for invalidation. */
+  $rpc<N extends Extract<keyof F, string>>(name: N, args?: RpcArgsOf<F, N> | SkipToken, options?: {
+    readonly tables?: readonly TableKey<M>[];
+  }): QueryOptionsOf<F[N]["Returns"]>;
+  /** Mutation options for a database function; invalidates what `sb.defineRpc` declared. */
+  $rpcMutation<N extends Extract<keyof F, string>>(name: N): MutationOptionsOf<RpcArgsOf<F, N>, F[N]["Returns"]>;
+}
+type Queries<M extends AnyModels, E, F extends AnyFunctions = AnyFunctions> = { readonly [T in TableKey<M>]: TableQueries<M, T, E>; } & QueryHelpers<M, F>;
+interface CreateQueriesOptions {
+  /**
+   * `staleTime` for every query option. Set it above zero when rendering on
+   * the server so hydrated data isn't refetched on mount.
+   */
+  readonly staleTime?: number;
+}
+/**
+ * TanStack Query option factories for every table, framework-neutral: pass
+ * them to `useQuery` (React), `createQuery` (Svelte, Solid), `useQuery`
+ * (Vue) or `injectQuery` (Angular). Payload types flow into the cache, errors
+ * are `DbException`s, and mutations invalidate every query that read a
+ * changed table.
+ *
+ * ```ts
+ * const q = createQueries(sb, () => browser.db);
+ * const { data } = useQuery(q.customers.findMany({ select: ['id', 'name'] }));
+ * ```
+ */
+declare function createQueries<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, db: Db<M, F, E, unknown> | (() => Db<M, F, E, unknown>), options?: CreateQueriesOptions): Queries<M, E, F>;
+/** Invalidates every query that read a table in the target. */
+declare function queryCache(client: QueryClient): CacheAdapter;
+/** Invalidates affected queries for every mutation and declared RPC `sb` performs in this runtime. */
+declare function invalidateOnMutation<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>, client: QueryClient): () => void;
+//#endregion
+export { QueryHelpers as a, TableQueries as c, queryCache as d, BetterQueryMeta as f, Queries as i, createQueries as l, InfiniteOptionsOf as n, QueryKeyOf as o, invalidateTables as p, MutationOptionsOf as r, QueryOptionsOf as s, CreateQueriesOptions as t, invalidateOnMutation as u };

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { A as SchemaMeta, C as PrimaryKeyValue, D as Relations, E as RelationShape, F as UniqueConstraint, I as UniqueKeyName, L as UniqueWhere, M as TableFlags, N as TableKey, O as Row, P as TableMeta, R as Update, S as PrimaryKeyColumn, T as RelationMeta, _ as Insert, a as Casing, b as PermdockBucketPolicy, c as Codec, d as Flags, f as FlagsShape, g as FunctionsOf, h as FunctionShape, i as BucketPolicyName, j as Simplify, k as Schema, l as ColumnMeta, m as FunctionMeta, n as AnyModels, o as CheckConstraint, p as ForeignKeyConstraint, r as BucketMeta, s as ClaimsMeta, t as AnyFunctions, u as DatabaseOf, v as ModelShape, w as RealtimeTableMeta, x as PermdockTopicPolicy, y as ModelsOf } from "./types-C83v5SQz.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-CGdNQ27g.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-DOt3nSO-.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-e3zI4_4g.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-C4TR9J0Z.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-cAEQ_IQN.js";
+import { n as StoragePath } from "./path-Cv__-OTj.js";
+import { n as postgrestCompiler, t as Compiler } from "./compiler-CZ9nIuqy.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-CqorWDnO.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 BucketPolicyName, type CacheAdapter, type CacheTarget, type CallOptions, type Casing, type CheckConstraint, type ClaimsMeta, 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 PermdockBucketPolicy, type PermdockTopicPolicy, 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,43 @@
+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-bwJpLnaS.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 rowKey, i as encodeCursor, l as rpcCacheTargets, n as defineSupabase, o as cacheTargetOf, r as decodeCursor, s as memoryCache, t as BetterSupabase } from "./define-BXMYD9AY.js";
+import { n as touchedTables, t as invalidationTargets } from "./tables-rZxRxNPW.js";
+import { n as silentLogger, t as consoleLogger } from "./logger-glM28NVN.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-C5W-rBfR.js";
+import { c as readSetTables, d as isQuerySpec, f as specTables, i as defineReadSet, o as isReadSet } from "./read-set-4lI3W_gZ.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-BTkTtRV9.js";
+import { t as SPEC_PINS } from "./spec-pins-C3oc-Tdp.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 };