better-supabase 0.4.0 → 0.5.1

package/dist/cli/sql-D4VbqmXi.js

@@ -1,199 +0,0 @@
-import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
-import { i as plain, r as painter } from "./style-C0NFdJRL.js";
-import { d as readSupabaseToml, f as schemaPaths, l as migrationCommand } from "./config-D9R0o1LH.js";
-import { c as readPermdock, l as fileDiff, o as permdockConfig, r as entitlementsMode, t as compiledReadSets } from "./read-sets-CMa29t9a.js";
-import { resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { SQL_MODULES, kitLayout, renderKit, resolveModules, sameKitFile } from "better-supabase/sql";
-//#region src/cli/commands/sql.ts
-const SQL_ARGS = {
-	action: {
-		type: "positional",
-		required: false,
-		description: "list (modules and whether they are installed), add <module...>, sync or print <module>"
-	},
-	check: {
-		type: "boolean",
-		description: "With sync: fail when a file is stale"
-	},
-	"tests-dir": {
-		type: "string",
-		description: "Where the pgtap module goes. Defaults to sql.testsDir",
-		valueHint: "dir"
-	},
-	"dry-run": {
-		type: "boolean",
-		description: "Show what would be written"
-	},
-	force: {
-		type: "boolean",
-		description: "Write tenant even though a permdock.config.ts is present"
-	}
-};
-const USAGE = "Run `better-supabase sql --help` for the actions.";
-/** Modules that fill a claim PermDock's hook also writes (`memberships`). */
-const PERMDOCK_OWNED = /* @__PURE__ */ new Set(["tenant"]);
-/** PermDock's helpers for the `entitlements` module; throws for a scope the manifest lacks. */
-async function permdockFor(config) {
-	const mode = entitlementsMode(config, await readPermdock(config.root, config.permdock));
-	switch (mode.kind) {
-		case "tenant": return;
-		case "permdock": return mode.permdock;
-		case "invalid": throw new TypeError(mode.problem);
-		default: return mode;
-	}
-}
-async function layout(config, args) {
-	return kitLayout(config, args["tests-dir"], [], await permdockFor(config));
-}
-/** The layout, with `config.readSets` compiled when `names` includes `read-sets`. */
-async function layoutFor(config, args, names) {
-	const permdock = await permdockFor(config);
-	const needsReadSets = resolveModules(names, { ...permdock ? { permdock } : {} }).some((module) => module.name === "read-sets");
-	return kitLayout(config, args["tests-dir"], needsReadSets ? await compiledReadSets(config) : [], permdock);
-}
-async function write(config, args, names, kit) {
-	const lines = [];
-	const dryRun = args["dry-run"] === true;
-	for (const file of renderKit(names, kit)) {
-		const path = resolve(config.root, file.path);
-		const shown = display(config.root, file.path);
-		if (dryRun) {
-			lines.push(`Would write ${shown} (${file.module})`);
-			continue;
-		}
-		const wrote = await writeIfChanged(path, file.contents);
-		lines.push(`${wrote ? "Wrote" : "Unchanged"} ${shown} (${file.module})`);
-	}
-	return lines;
-}
-/** A note when migra's `schema_paths` is set and misses kit files, which `supabase db diff` would then skip. */
-async function unlistedKitFiles(config, names, kit) {
-	const order = await schemaPaths(config.root, await readSupabaseToml(config.root));
-	if (!order.configured) return [];
-	const unlisted = new Set(order.unlisted);
-	const listed = new Set(order.files.filter((path) => !unlisted.has(path)));
-	const dir = `${config.sql.dir.replace(/\/$/, "")}/`;
-	const missing = renderKit(names, kit).map((file) => file.path).filter((path) => path.startsWith(dir) && !listed.has(path));
-	if (missing.length === 0) return [];
-	return [
-		"",
-		"supabase/config.toml sets [db.migrations] schema_paths, and no entry matches these files, so `supabase db diff` skips them.",
-		"Add them before the schemas that call their functions:",
-		...missing.map((path) => `  "./${path.startsWith("supabase/") ? path.slice(9) : path}",`)
-	];
-}
-async function runSql(config, args, paint = plain) {
-	const [action, ...names] = args._;
-	switch (action) {
-		case "list": {
-			const kit = await layout(config, args);
-			const files = new Map(renderKit(Object.keys(SQL_MODULES), kit).map((file) => [file.module, file.path]));
-			return {
-				code: 0,
-				output: `${Object.values(SQL_MODULES).map((module) => {
-					const path = files.get(module.name);
-					const installed = existsSync(resolve(config.root, path));
-					const tracked = config.sql.kit.includes(module.name);
-					const mark = installed ? tracked ? "●" : "○" : " ";
-					const requires = kit.permdock && module.permdockRequires ? module.permdockRequires : module.requires;
-					const needs = requires.length > 0 ? ` (needs ${requires.join(", ")})` : "";
-					return `${mark} ${module.name.padEnd(15)} ${module.description}${needs}`;
-				}).join("\n")}\n\n● installed and in sql.kit   ○ installed, not in sql.kit`
-			};
-		}
-		case "add": {
-			if (names.length === 0) return {
-				code: 2,
-				error: `Name at least one module.\n${USAGE}`
-			};
-			const unknown = names.filter((name) => !(name in SQL_MODULES));
-			if (unknown.length > 0) return {
-				code: 2,
-				error: `Unknown module ${unknown.join(", ")}. Available: ${Object.keys(SQL_MODULES).join(", ")}`
-			};
-			const permdock = permdockConfig(config.root);
-			const hookModules = names.filter((name) => PERMDOCK_OWNED.has(name));
-			if (permdock && hookModules.length > 0 && args.force !== true) return {
-				code: 1,
-				error: [
-					`${permdock} is present, so PermDock owns the access token hook and the memberships claim.`,
-					`${hookModules.join(" and ")} would add a second source for them. Use \`permdock supabase hook generate\` instead,`,
-					"or pass --force to write the modules anyway."
-				].join("\n")
-			};
-			const kit = await layoutFor(config, args, names);
-			const lines = await write(config, args, names, kit);
-			const pulledIn = resolveModules(names, kit).map((module) => module.name).filter((name) => PERMDOCK_OWNED.has(name) && !names.includes(name));
-			if (permdock && pulledIn.length > 0) lines.push("", `${pulledIn.join(" and ")} came along as a dependency: its memberships table backs has_org_role() and has_entitlement().`, `PermDock's hook still owns the memberships claim, so don't call better_supabase.membership_claims from a hook.`, "List better_supabase.memberships as a PermDock membership source if both should agree.");
-			const untracked = resolveModules(names, kit).map((module) => module.name).filter((name) => !config.sql.kit.includes(name));
-			if (untracked.length > 0) lines.push("", `Add them to your config so \`sql sync --check\` keeps them current:`, `  sql: { kit: [${[...config.sql.kit, ...untracked].map((name) => `'${name}'`).join(", ")}] }`);
-			if (args["dry-run"] !== true) lines.push(...await unlistedKitFiles(config, names, kit));
-			lines.push("", `Then create a migration: ${migrationCommand(await readSupabaseToml(config.root), "better_supabase_kit")}`);
-			return {
-				code: 0,
-				output: lines.join("\n")
-			};
-		}
-		case "sync": {
-			if (config.sql.kit.length === 0) return {
-				code: 0,
-				output: "sql.kit is empty; nothing to sync."
-			};
-			if (args.check !== true) return {
-				code: 0,
-				output: (await write(config, args, config.sql.kit, await layoutFor(config, args, config.sql.kit))).join("\n")
-			};
-			const stale = [];
-			const diffs = [];
-			for (const file of renderKit(config.sql.kit, await layoutFor(config, args, config.sql.kit))) {
-				const current = await readFile(resolve(config.root, file.path), "utf8").catch(() => void 0);
-				if (!sameKitFile(current, file.contents)) {
-					const shown = display(config.root, file.path);
-					stale.push(shown);
-					diffs.push(fileDiff(shown, current, file.contents, paint));
-				}
-			}
-			return stale.length === 0 ? {
-				code: 0,
-				output: "SQL kit files are up to date."
-			} : {
-				code: 1,
-				output: diffs.join("\n\n"),
-				error: `Out of date: ${stale.join(", ")}. Run \`better-supabase sql sync\`.`
-			};
-		}
-		case "print": {
-			const [name] = names;
-			const module = name ? SQL_MODULES[name] : void 0;
-			if (!module) return {
-				code: 2,
-				error: `Name one module: ${Object.keys(SQL_MODULES).join(", ")}`
-			};
-			return {
-				code: 0,
-				output: module.render ? module.render(config.claims, await layout(config, args)) : module.sql
-			};
-		}
-		case void 0: return {
-			code: 2,
-			error: `Name an action.\n${USAGE}`
-		};
-		default: return {
-			code: 2,
-			error: `Unknown sql action "${action}".\n${USAGE}`
-		};
-	}
-}
-const sqlCommand = defineCliCommand({
-	meta: {
-		name: "sql",
-		description: "Lists, adds, syncs and prints SQL kit modules"
-	},
-	args: SQL_ARGS,
-	run: (args, { config, io }) => runSql(config, args, painter(io.color))
-});
-//#endregion
-export { sqlCommand };

package/dist/events-B21UOhvP.d.ts

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

package/dist/executor-B5IoUxLE.d.ts

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

package/dist/invalidate-CgxmRamI.js

@@ -1,24 +0,0 @@
-//#region src/query/invalidate.ts
-function isString(value) {
-	return typeof value === "string";
-}
-function queryTables(query) {
-	const tables = query.meta?.["bsTables"];
-	if (Array.isArray(tables)) {
-		const list = tables;
-		return list.every(isString) ? list : list.filter(isString);
-	}
-	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 };

package/dist/permdock-sql-DImJULY-.d.ts

@@ -1,17 +0,0 @@
-//#region src/core/permdock-sql.d.ts
-/**
- * The part of PermDock's `permissions.catalog.json` the Storage and Realtime
- * builders read: `import catalog from './permissions.catalog.json'`.
- */
-interface PermdockCatalog {
-  readonly permissions: readonly {
-    readonly key: string;
-    readonly rowConditions?: boolean;
-  }[];
-}
-/** The keys a bucket or topic PermDock policy names. */
-declare function permdockKeys(policy: {
-  readonly permdock: object;
-}): string[];
-//#endregion
-export { permdockKeys as n, PermdockCatalog as t };

package/dist/plugin-BqR6wKMB.js

@@ -1,23 +0,0 @@
-//#region src/core/plugin.ts
-const PLUGIN_API_VERSION = 1;
-const RANK = {
-	pre: 0,
-	normal: 1,
-	post: 2
-};
-/** Plugins in hook order: `pre`, then unmarked in `use()` order, then `post`. */
-function orderPlugins(plugins) {
-	return plugins.map((plugin, index) => ({
-		plugin,
-		index
-	})).sort((a, b) => RANK[a.plugin.enforce ?? "normal"] - RANK[b.plugin.enforce ?? "normal"] || a.index - b.index).map(({ plugin }) => plugin);
-}
-/** Identity helper that fixes `apiVersion` and infers the plugin types. */
-function definePlugin(plugin) {
-	return {
-		...plugin,
-		apiVersion: 1
-	};
-}
-//#endregion
-export { definePlugin as n, orderPlugins as r, PLUGIN_API_VERSION as t };