better-supabase 0.7.0 → 0.8.0

package/dist/svelte/index.d.ts

@@ -1,12 +1,11 @@
-import { b as DbError } from "../result-D7y2fT87.js";
-import { it as QuerySpec } from "../define-CJJkkr1-.js";
-import { n as TemplateValues } from "../template-CwO38Do8.js";
-import { t as AuthSnapshot } from "../bind-Bu_ZNa3W.js";
-import { t as AuthSession } from "../view-CF7ihnkg.js";
-import { S as Topic, f as PresenceMember, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus } from "../index-DunNRdnT.js";
-import { a as BroadcastOptions, c as LiveCountSource, d as PresenceTopic, f as UseActionOptions, i as ActionState, l as LiveQueryHookOptions, n as ActionInputOf, o as ClientLike, r as ActionResultOf, s as LiveCountHookOptions, t as fieldErrorsOf, u as PresenceHookOptions } from "../field-errors-BFOa7WhB.js";
+import { b as DbError } from "../result-BchM1XZn.js";
+import { J as TemplateValues } from "../storage-api-CB7Zl1Ci.js";
+import { at as QuerySpec } from "../define-DmcfoNXB.js";
+import { t as AuthSnapshot } from "../bind-CQ5mPyX1.js";
+import { t as AuthSession } from "../view-TpXEUcVN.js";
+import { S as Topic, f as PresenceMember, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus } from "../index-BCHR4Ucl.js";
+import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-DIe9XYWL.js";
 import { SupabaseClient } from "@supabase/supabase-js";
-import { StandardSchemaV1 } from "@standard-schema/spec";
 import { QueryClient } from "@tanstack/query-core";
 //#region src/svelte/index.d.ts
 /** A value read through `.current`, reactive in templates, `$derived` and `$effect`. */
@@ -36,14 +35,6 @@ export interface ActionHandle<I, T> extends ActionState<I, T> {
   readonly run: (input: I) => Promise<ActionResultOf<T>>;
   readonly reset: () => void;
 }
-/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
-export type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
-  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
-} ? C : unknown;
-/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
-export type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
-  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
-} ? P : unknown;
 /**
  * The client bound to Svelte. Inputs are getters (`() => spec`), so the
  * subscriptions follow `$state` and `$props`. A subscription starts when a
@@ -111,4 +102,4 @@ export declare function setSession(session: () => AuthSession): void;
 /** The session from the nearest `setSession()`, typed with `useSession<Claims, Profile>()`. */
 export declare function useSession<C = unknown, P = unknown>(): Current<AuthSession<C, P>>;
 //#endregion
-export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type UseActionOptions, fieldErrorsOf };
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type UseActionOptions, fieldErrorsOf };

package/dist/svelte/index.js

@@ -1,6 +1,6 @@
 import { t as clearOnUserChange } from "../user-change-XzvgafU4.js";
-import { t as fieldErrorsOf } from "../field-errors-VF1yb8yI.js";
-import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-CI0Z2zWX.js";
+import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-wxeTQFtB.js";
+import { t as fieldErrorsOf } from "../field-errors-DZVRWRkf.js";
 import { getContext, onMount, setContext } from "svelte";
 import { createSubscriber } from "svelte/reactivity";
 //#region src/svelte/index.ts

package/dist/sveltekit/index.d.ts

@@ -1,11 +1,11 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
-import { t as BetterSupabase } from "../define-CJJkkr1-.js";
-import { t as BetterServer } from "../server-ZSJ9rCcV.js";
-import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-CkNzZUqv.js";
-import { t as RefusalRedirects } from "../refusal-DhSU2Vvr.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-KIPvRQJU.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-CoE5Zwy4.js";
+import { t as BetterSupabase } from "../define-DmcfoNXB.js";
+import { t as BetterServer } from "../server-types-CrAmZ8jv.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-W99LCPBS.js";
+import { t as RefusalRedirects } from "../refusal-CFI8-5nf.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-148t1m3C.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
-import { i as tagFor } from "../tags-Cx-LnIQP.js";
+import { i as tagFor } from "../tags-BO9LjtWG.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/bridges/sveltekit.d.ts

package/dist/sveltekit/index.js

@@ -1,13 +1,13 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { r as dbErrorOf } from "../errors-B11Duf73.js";
-import { o as toProblem } from "../problem-BreOl8b8.js";
-import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-B-tL8hqg.js";
-import { t as defaultExpose } from "../respond-BUgsXNgk.js";
+import { r as dbErrorOf } from "../errors-2M6CKMP4.js";
+import { s as toProblem } from "../problem-CJvFeGu7.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-CN45ibbV.js";
+import { t as defaultExpose } from "../respond-volM3ByS.js";
 import { r as tagFor } from "../tags-B99_U9Pp.js";
-import { i as requireCaller, o as runAction } from "../kit-Fm-Fv7q5.js";
+import { i as requireCaller, o as runAction } from "../kit-BhHr9T9v.js";
 import { n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
-import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-BDCpJI7o.js";
-import { i as refusalTarget } from "../refusal-CeJWxmkH.js";
+import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-3ey3QmrO.js";
+import { i as refusalTarget } from "../refusal-K78A1Vmq.js";
 //#region src/bridges/sveltekit.ts
 /**
 * Runs an entry array as a SvelteKit `handle` hook. Every contributed key
@@ -57,9 +57,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 		const env = event.platform?.env;
 		return run(event.request, env, async (contributions) => {
 			Object.assign(event.locals, localsOf(contributions));
-			const response = await resolve(event);
-			flushEvents(server, options.waitUntil ?? platformWaitUntil(platform));
-			return response;
+			return withFlush(server, options.waitUntil ?? platformWaitUntil(platform), () => resolve(event));
 		});
 	};
 	return extendServer(server, {
@@ -67,7 +65,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 		handle,
 		require: async (event, requireOptions = {}) => {
 			const locals = localsFrom(event);
-			const caller = await requireCaller(locals.bs.auth, requireOptions, locals.tenant);
+			const caller = await requireCaller(locals.bs.auth, requireOptions, locals.tenant, options.authorizer);
 			if ("kind" in caller) return refuse(caller, event.request);
 			return {
 				...locals,
@@ -81,7 +79,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 				const result = await runAction(locals.bs.auth, actionOptions, input, locals.tenant, (parsed, caller) => fn(parsed, {
 					...locals,
 					...caller
-				}, event));
+				}, event), options.authorizer);
 				if (!result.ok && options.kit) return options.kit.fail(result.error.status, result);
 				return result;
 			};

package/dist/table-schema-htM_SbCW.js

@@ -0,0 +1,286 @@
+import { i as isPlainDateTime, n as isInstant } from "./temporal-BJGitm-h.js";
+import { t as isList } from "./guards-6F2bCtQR.js";
+//#region src/core/table-json-schema.ts
+/** JSON Schema for one scalar. Codec values are described by their wire form. */
+function scalarJsonSchema(kind) {
+	switch (kind.kind) {
+		case "uuid": return {
+			type: "string",
+			format: "uuid"
+		};
+		case "string": return { type: "string" };
+		case "integer": return { type: "integer" };
+		case "number": return { type: "number" };
+		case "boolean": return { type: "boolean" };
+		case "datetime": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "date": return {
+			type: "string",
+			format: "date"
+		};
+		case "instant": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "plainDateTime": return {
+			type: "string",
+			pattern: "^\\d{4}-\\d{2}-\\d{2}[T ]\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?$"
+		};
+		case "bigint": return {
+			type: "string",
+			pattern: "^-?\\d+$"
+		};
+		case "json":
+		case "unknown":
+		case "custom": return {};
+		case "enum": return {
+			type: "string",
+			enum: [...kind.values]
+		};
+		default: return kind;
+	}
+}
+/** Wraps a column's schema for arrays and `null`. */
+function columnJsonSchema(base, field) {
+	const schema = field.array ? {
+		type: "array",
+		items: base
+	} : base;
+	if (!field.nullable) return schema;
+	if (Object.keys(schema).length === 0) return schema;
+	const { enum: values, ...rest } = schema;
+	if (isList(values)) return {
+		...rest,
+		type: ["string", "null"],
+		enum: [...values, null]
+	};
+	return typeof schema["type"] === "string" ? {
+		...schema,
+		type: [schema["type"], "null"]
+	} : { anyOf: [schema, { type: "null" }] };
+}
+const BOUND_KEYS = [
+	"minimum",
+	"exclusiveMinimum",
+	"maximum",
+	"exclusiveMaximum",
+	"minLength",
+	"maxLength"
+];
+function propertySchema(field, base) {
+	const bounds = {};
+	for (const key of BOUND_KEYS) {
+		const value = field[key];
+		if (value !== void 0) bounds[key] = value;
+	}
+	const schema = {
+		...columnJsonSchema({
+			...base,
+			...bounds
+		}, field),
+		...field.description === void 0 ? {} : { description: field.description },
+		...field.examples === void 0 ? {} : { examples: [...field.examples] }
+	};
+	return field.readOnly ? {
+		...schema,
+		readOnly: true
+	} : schema;
+}
+/**
+* The JSON Schema object for a table shape. `nested` converts a typed jsonb
+* column's own schema; without it those columns accept any value.
+*/
+function tableJsonSchema(spec, nested) {
+	const properties = {};
+	const required = [];
+	for (const [name, field] of Object.entries(spec.fields)) {
+		properties[name] = propertySchema(field, (field.schema && nested?.(field.schema)) ?? scalarJsonSchema(field));
+		if (!field.optional) required.push(name);
+	}
+	return {
+		...spec.title === void 0 ? {} : { title: spec.title },
+		...spec.description === void 0 ? {} : { description: spec.description },
+		type: "object",
+		properties,
+		...required.length > 0 ? { required } : {},
+		additionalProperties: false
+	};
+}
+//#endregion
+//#region src/core/table-schema.ts
+const SCHEMA_URIS = {
+	"draft-2020-12": "https://json-schema.org/draft/2020-12/schema",
+	"draft-07": "http://json-schema.org/draft-07/schema#"
+};
+function isObject(value) {
+	return typeof value === "object" && value !== null && !isList(value);
+}
+/** Rewrites a 2020-12 schema into the OpenAPI 3.0 dialect (`nullable`, `example`). */
+function toOpenApi30(schema) {
+	const out = {};
+	for (const [key, value] of Object.entries(schema)) if (key === "properties" && isObject(value)) out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, isObject(child) ? toOpenApi30(child) : child]));
+	else if (key === "items" && isObject(value)) out[key] = toOpenApi30(value);
+	else if (key === "examples" && isList(value)) {
+		if (value.length > 0) out["example"] = value[0];
+	} else if (key === "exclusiveMinimum" || key === "exclusiveMaximum") {
+		out[key === "exclusiveMinimum" ? "minimum" : "maximum"] = value;
+		out[key] = true;
+	} else out[key] = value;
+	const type = out["type"];
+	if (isList(type) && type.includes("null")) {
+		out["type"] = type.find((entry) => entry !== "null");
+		out["nullable"] = true;
+	}
+	const anyOf = out["anyOf"];
+	if (isList(anyOf) && anyOf.length === 2) {
+		const [inner, empty] = anyOf;
+		if (isObject(inner) && isObject(empty) && empty["type"] === "null") {
+			delete out["anyOf"];
+			return {
+				...toOpenApi30(inner),
+				...out,
+				nullable: true
+			};
+		}
+	}
+	return out;
+}
+/** The schema with the target's `$schema`, or in the OpenAPI 3.0 dialect. */
+function forTarget(schema, target) {
+	if (target === "openapi-3.0") return toOpenApi30(schema);
+	const uri = SCHEMA_URIS[target];
+	if (!uri) throw new Error(`Unsupported JSON Schema target "${target}"`);
+	return {
+		$schema: uri,
+		...schema
+	};
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
+function isJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (isList(value)) return value.every(isJson);
+	if (!isObject(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return (proto === Object.prototype || proto === null) && Object.values(value).every(isJson);
+}
+/** The issue message for a scalar, or `undefined` when the value passes. */
+function scalarIssue(field, value) {
+	switch (field.kind) {
+		case "uuid": return typeof value === "string" && UUID.test(value) ? void 0 : "Expected a UUID";
+		case "string": return typeof value === "string" ? void 0 : "Expected a string";
+		case "integer": return Number.isSafeInteger(value) ? void 0 : "Expected an integer";
+		case "number": return typeof value === "number" && Number.isFinite(value) ? void 0 : "Expected a number";
+		case "boolean": return typeof value === "boolean" ? void 0 : "Expected a boolean";
+		case "datetime": return typeof value === "string" && DATETIME.test(value) ? void 0 : "Expected an ISO 8601 date-time with an offset";
+		case "date": return typeof value === "string" && DATE.test(value) ? void 0 : "Expected an ISO 8601 date";
+		case "instant": return isInstant(value) ? void 0 : "Expected a Temporal.Instant";
+		case "plainDateTime": return isPlainDateTime(value) ? void 0 : "Expected a Temporal.PlainDateTime";
+		case "bigint": return typeof value === "bigint" ? void 0 : "Expected a bigint";
+		case "json": return isJson(value) ? void 0 : "Expected a JSON value";
+		case "enum": return typeof value === "string" && field.values.includes(value) ? void 0 : `Expected one of ${field.values.map((entry) => JSON.stringify(entry)).join(", ")}`;
+		case "unknown": return;
+		case "custom": return value === void 0 ? "Expected a value" : void 0;
+		default: return field;
+	}
+}
+const characters = (count) => count === 1 ? "1 character" : `${count} characters`;
+function boundIssue(field, value) {
+	if (typeof value === "number") {
+		if (field.minimum !== void 0 && value < field.minimum) return `Expected at least ${field.minimum}`;
+		if (field.exclusiveMinimum !== void 0 && value <= field.exclusiveMinimum) return `Expected more than ${field.exclusiveMinimum}`;
+		if (field.maximum !== void 0 && value > field.maximum) return `Expected at most ${field.maximum}`;
+		if (field.exclusiveMaximum !== void 0 && value >= field.exclusiveMaximum) return `Expected less than ${field.exclusiveMaximum}`;
+	}
+	if (typeof value === "string") {
+		if (field.minLength !== void 0 && value.length < field.minLength) return `Expected at least ${characters(field.minLength)}`;
+		if (field.maxLength !== void 0 && value.length > field.maxLength) return `Expected at most ${characters(field.maxLength)}`;
+	}
+}
+function nestedIssues(result, path) {
+	return (result.issues ?? []).map((issue) => ({
+		message: issue.message,
+		path: [...path, ...issue.path ?? []]
+	}));
+}
+/** Checks one element; a nested schema's async result lands in `pending`. */
+function checkValue(field, value, path, issues, pending) {
+	if (field.schema) {
+		const result = field.schema["~standard"].validate(value);
+		if (result instanceof Promise) pending.push(result.then((settled) => nestedIssues(settled, path)));
+		else issues.push(...nestedIssues(result, path));
+		return;
+	}
+	const message = scalarIssue(field, value) ?? boundIssue(field, value);
+	if (message) issues.push({
+		message,
+		path: [...path]
+	});
+}
+function checkField(name, field, value, issues, pending) {
+	if (value === null && field.nullable) return;
+	if (!field.array) {
+		checkValue(field, value, [name], issues, pending);
+		return;
+	}
+	if (!isList(value)) {
+		issues.push({
+			message: "Expected an array",
+			path: [name]
+		});
+		return;
+	}
+	value.forEach((item, index) => {
+		checkValue(field, item, [name, index], issues, pending);
+	});
+}
+/**
+* A Standard Schema for one table shape, without a validation library. It
+* validates like the `zod()` and `valibot()` output, drops unknown keys, and
+* converts to JSON Schema for `draft-2020-12`, `draft-07` and `openapi-3.0`.
+* The `standardSchema()` generator emits one per Row, Insert and Update.
+*/
+function tableSchema(spec) {
+	const entries = Object.entries(spec.fields);
+	const validate = (input) => {
+		if (!isObject(input)) return { issues: [{ message: "Expected an object" }] };
+		const issues = [];
+		const pending = [];
+		const value = {};
+		for (const [name, field] of entries) {
+			if (!Object.hasOwn(input, name)) {
+				if (!field.optional && field.kind !== "unknown") issues.push({
+					message: "Required",
+					path: [name]
+				});
+				continue;
+			}
+			value[name] = input[name];
+			checkField(name, field, input[name], issues, pending);
+		}
+		const settle = (all) => all.length > 0 ? { issues: all } : { value };
+		if (pending.length === 0) return settle(issues);
+		return Promise.all(pending).then((nested) => settle([...issues, ...nested.flat()]));
+	};
+	const convert = (direction) => (options) => forTarget(tableJsonSchema(spec, (schema) => {
+		const converted = schema["~standard"].jsonSchema?.[direction](options);
+		if (!converted) return converted;
+		const { $schema: _, ...rest } = converted;
+		return rest;
+	}), options.target);
+	return { "~standard": {
+		version: 1,
+		vendor: "better-supabase",
+		validate,
+		jsonSchema: {
+			input: convert("input"),
+			output: convert("output")
+		}
+	} };
+}
+//#endregion
+export { tableSchema as n, tableJsonSchema as r, forTarget as t };

package/dist/{tags-Cx-LnIQP.d.ts → tags-BO9LjtWG.d.ts}

@@ -1,4 +1,4 @@
-import { d as CacheTarget, u as CacheAdapter } from "./define-CJJkkr1-.js";
+import { c as CacheTarget, s as CacheAdapter } from "./define-DmcfoNXB.js";
 //#region src/core/tags.d.ts
 interface TagOptions {
   /** The tenant the read is scoped to; `"*"` is every tenant's reads. */

package/dist/tanstack-db/index.d.ts

@@ -1,5 +1,5 @@
-import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
-import { b as Db, t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../types-CoE5Zwy4.js";
+import { _ as Db, t as BetterSupabase } from "../define-DmcfoNXB.js";
 import { t as BetterQueryMeta } from "../invalidate-BBqhpxyB.js";
 import { QueryClient, SkipToken } from "@tanstack/query-core";
 //#region src/tanstack-db/collection.d.ts

package/dist/tanstack-db/supabase/index.d.ts

@@ -0,0 +1,52 @@
+import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../../types-CoE5Zwy4.js";
+import { _ as Db, t as BetterSupabase } from "../../define-DmcfoNXB.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { supabaseCollectionOptions } from "@supabase-labs/tanstack-db";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/tanstack-db/supabase/collection.d.ts
+type LabsConfig<Schema extends StandardSchemaV1> = ReturnType<typeof supabaseCollectionOptions<Schema>>;
+/**
+ * What `supabaseCollectionOptions()` from `@supabase-labs/tanstack-db`
+ * returns, without `undefined` in its optional properties, so `createCollection()`
+ * accepts it under `exactOptionalPropertyTypes`.
+ */
+type SupabaseCollectionConfig<Schema extends StandardSchemaV1> = { [K in keyof LabsConfig<Schema>]: Exclude<LabsConfig<Schema>[K], undefined>; };
+interface BaseOptions<Schema extends StandardSchemaV1> {
+  /** The row schema, in database column names: `customersRow` from `standardSchema()`, `zod()` or `valibot()`. */
+  readonly schema: Schema;
+  /** Applies inserts, updates and deletes from other clients through Realtime `postgres_changes`. */
+  readonly realtime?: boolean;
+  /** Pushes each live query's filter to the Realtime subscription. Defaults to `false`. */
+  readonly realtimeUseFilter?: boolean;
+  readonly queryClient?: QueryClient;
+}
+type SupabaseCollectionOptions<M extends AnyModels, F extends AnyFunctions, E, Schema extends StandardSchemaV1> = BaseOptions<Schema> & ({
+  /** Sends writes through the table's repository (the default), so RLS, hooks, events and plugins apply. */
+  readonly writes?: "repository";
+  readonly db: Db<M, F, E, unknown> | (() => Db<M, F, E, unknown>);
+} | {
+  /** Sends writes straight to PostgREST with the supabase client, like `@supabase-labs/tanstack-db`. */
+  readonly writes: "direct";
+  readonly db?: never;
+});
+/**
+ * A TanStack DB collection on `@supabase-labs/tanstack-db`: live queries load
+ * on demand through PostgREST, Realtime keeps them current, and writes go
+ * through the table's repository by default. Rows use database column names,
+ * so the schema must use `casing: "snake"`, and the table must live in the
+ * `public` schema, which is the one the Realtime listener watches.
+ *
+ * ```ts
+ * const customers = createCollection(
+ *   supabaseCollection(betterSupabase, supabase, "customers", {
+ *     schema: customersRow,
+ *     db,
+ *     realtime: true,
+ *   }),
+ * );
+ * ```
+ */
+export declare function supabaseCollection<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, Schema extends StandardSchemaV1>(betterSupabase: BetterSupabase<M, D, F, E>, supabase: SupabaseClient, table: T, options: SupabaseCollectionOptions<M, F, E, Schema>): SupabaseCollectionConfig<Schema>;
+//#endregion
+export type { SupabaseCollectionConfig, SupabaseCollectionOptions };

package/dist/tanstack-db/supabase/index.js

@@ -0,0 +1,97 @@
+import { t as DbException } from "../../db-exception-CnWcYPxL.js";
+import { supabaseCollectionOptions } from "@supabase-labs/tanstack-db";
+//#region src/tanstack-db/supabase/collection.ts
+function field(row, name) {
+	if (typeof row !== "object" || row === null || !(name in row)) return void 0;
+	return Object.getOwnPropertyDescriptor(row, name)?.value;
+}
+/**
+* A TanStack DB collection on `@supabase-labs/tanstack-db`: live queries load
+* on demand through PostgREST, Realtime keeps them current, and writes go
+* through the table's repository by default. Rows use database column names,
+* so the schema must use `casing: "snake"`, and the table must live in the
+* `public` schema, which is the one the Realtime listener watches.
+*
+* ```ts
+* const customers = createCollection(
+*   supabaseCollection(betterSupabase, supabase, "customers", {
+*     schema: customersRow,
+*     db,
+*     realtime: true,
+*   }),
+* );
+* ```
+*/
+function supabaseCollection(betterSupabase, supabase, table, options) {
+	const { meta } = betterSupabase;
+	if (meta.casing !== "snake") throw new TypeError(`better-supabase: supabaseCollection() needs casing: "snake"; @supabase-labs/tanstack-db reads and writes database column names. Use collectionOptions() with camel casing.`);
+	const tableMeta = meta.tables[table];
+	if (!tableMeta) throw new TypeError(`better-supabase: unknown table "${table}"`);
+	if (tableMeta.schema !== "public") throw new TypeError(`better-supabase: supabaseCollection() supports tables in the public schema; "${tableMeta.schema}.${tableMeta.name}" is not.`);
+	const primaryKey = tableMeta.primaryKey;
+	const [single] = primaryKey;
+	if (single === void 0) throw new TypeError(`better-supabase: the "${table}" collection needs a table with a primary key`);
+	const config = supabaseCollectionOptions({
+		tableName: tableMeta.name,
+		keys: [...primaryKey],
+		schema: options.schema,
+		supabase,
+		...options.queryClient ? { queryClient: options.queryClient } : {},
+		...options.realtime === void 0 ? {} : { realtime: options.realtime },
+		...options.realtimeUseFilter === void 0 ? {} : { realtimeUseFilter: options.realtimeUseFilter }
+	});
+	if (options.writes === "direct") return config;
+	const { db } = options;
+	const writeBack = !Object.values(tableMeta.columns).some((column) => column.codec !== void 0);
+	const composite = primaryKey.length > 1;
+	const idOf = (row) => composite ? Object.fromEntries(primaryKey.map((name) => [name, field(row, name)])) : field(row, single);
+	const write = (method) => {
+		const fn = (typeof db === "function" ? db() : db)[table]?.[method];
+		if (!fn) throw new TypeError(`better-supabase: ${table}.${method} is not available`);
+		return fn;
+	};
+	const orThrow = async (result) => {
+		const settled = await result;
+		if (!settled.ok) throw new DbException(settled.error);
+		return settled.data;
+	};
+	const done = { refetch: !writeBack };
+	const onInsert = async ({ transaction, collection }) => {
+		const create = write("create");
+		for (const mutation of transaction.mutations) {
+			const row = await orThrow(create(mutation.modified));
+			if (!writeBack) continue;
+			mutation.modified = row;
+			collection.utils.writeUpsert(mutation.modified);
+		}
+		return done;
+	};
+	const onUpdate = async ({ transaction, collection }) => {
+		const update = write("update");
+		for (const mutation of transaction.mutations) {
+			const row = await orThrow(update(idOf(mutation.original), mutation.changes));
+			if (!writeBack) continue;
+			mutation.modified = row;
+			collection.utils.writeUpdate(mutation.modified);
+		}
+		return done;
+	};
+	const onDelete = async ({ transaction, collection }) => {
+		const remove = write("delete");
+		for (const mutation of transaction.mutations) {
+			await orThrow(remove(idOf(mutation.original)));
+			if (!writeBack) continue;
+			const key = collection.getKeyFromItem(mutation.original);
+			if (collection._state.syncedData.has(key)) collection.utils.writeDelete(key);
+		}
+		return done;
+	};
+	return {
+		...config,
+		onInsert,
+		onUpdate,
+		onDelete
+	};
+}
+//#endregion
+export { supabaseCollection };

package/dist/tanstack-start/index.d.ts

@@ -1,9 +1,9 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
-import { t as BetterSupabase } from "../define-CJJkkr1-.js";
-import { t as BetterServer } from "../server-ZSJ9rCcV.js";
-import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-CkNzZUqv.js";
-import { t as RefusalRedirects } from "../refusal-DhSU2Vvr.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-KIPvRQJU.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-CoE5Zwy4.js";
+import { t as BetterSupabase } from "../define-DmcfoNXB.js";
+import { t as BetterServer } from "../server-types-CrAmZ8jv.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-W99LCPBS.js";
+import { t as RefusalRedirects } from "../refusal-CFI8-5nf.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-148t1m3C.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";

package/dist/tanstack-start/index.js

@@ -1,9 +1,9 @@
-import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-B-tL8hqg.js";
-import { t as defaultExpose } from "../respond-BUgsXNgk.js";
-import { i as requireCaller, o as runAction } from "../kit-Fm-Fv7q5.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-CN45ibbV.js";
+import { t as defaultExpose } from "../respond-volM3ByS.js";
+import { i as requireCaller, o as runAction } from "../kit-BhHr9T9v.js";
 import { n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
-import { i as localsOf, r as frameworkEntry } from "../framework-BDCpJI7o.js";
-import { r as refusalResponse } from "../refusal-CeJWxmkH.js";
+import { i as localsOf, r as frameworkEntry } from "../framework-3ey3QmrO.js";
+import { r as refusalResponse } from "../refusal-K78A1Vmq.js";
 //#region src/bridges/tanstack-start.ts
 /** The `response` of a request middleware's `next()` result; server function results have none. */
 function responseOf(result) {
@@ -62,15 +62,11 @@ function createTanStackStart(betterSupabase, options = {}) {
 	};
 	return extendServer(server, {
 		async middleware(args) {
-			try {
-				return await served(args);
-			} finally {
-				flushEvents(server, options.waitUntil);
-			}
+			return withFlush(server, options.waitUntil, () => served(args));
 		},
 		require: async (context, requireOptions = {}) => {
 			const scope = scopeOf(context);
-			const caller = await requireCaller(scope.bs.auth, requireOptions, scope.tenant);
+			const caller = await requireCaller(scope.bs.auth, requireOptions, scope.tenant, options.authorizer);
 			if ("kind" in caller) {
 				const request = requests.get(scope) ?? new Request("http://localhost/");
 				throw refusalResponse(caller, request, options, expose);
@@ -86,7 +82,7 @@ function createTanStackStart(betterSupabase, options = {}) {
 				return await runAction(scope.bs.auth, actionOptions, data, scope.tenant, (parsed, caller) => fn(parsed, {
 					...scope,
 					...caller
-				}));
+				}), options.authorizer);
 			};
 		}
 	});

package/dist/{tee-CoEppCER.js → tee-Cb98Vn3b.js}

@@ -1,4 +1,4 @@
-import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DEqHCMKP.js";
 //#region src/streams/tee.ts
 /**
 * Copies `source` into `store` under `id` while passing it through. Chunks