better-supabase 0.12.0 → 0.13.0

package/dist/svelte/index.js

@@ -1,5 +1,5 @@
-import { t as clearOnUserChange } from "../user-change-XzvgafU4.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-CHR8IBNG.js";
+import { t as clearOnUserChange } from "../user-change-CSR_prhd.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-YASsOslj.js";
 import { t as fieldErrorsOf } from "../field-errors-DZVRWRkf.js";
 import { t as CLIENT } from "../context-C-bHOtoD.js";
 import { getContext, onMount, setContext } from "svelte";
@@ -14,10 +14,10 @@ function reactive(store) {
 	} };
 }
 /**
-* A subscription keyed by `key()`. The returned function goes in each
-* getter: it registers the reader, then restarts the subscription when the
-* key (read in the reader's tracking context) changed. Notifications are
-* queued, since a getter may run inside `$derived`, where writes throw.
+* A subscription keyed by `key()`. The returned function goes in each getter:
+* it registers the reader, then restarts the subscription when the key (read in
+* the reader's tracking context) changed. Notifications are queued, since a
+* getter may run inside `$derived`, where writes throw.
 */
 function followed(key, start) {
 	const run = keyed();
@@ -43,7 +43,10 @@ function followed(key, start) {
 	};
 }
 const NO_MEMBERS = [];
-/** Binds a client to Svelte without a component context, e.g. in tests or a module. */
+/**
+* Binds a client to Svelte without a component context, e.g. in tests or a
+* module.
+*/
 function createBetterSvelte(client, options = {}) {
 	const { queryClient } = options;
 	const auth = reactive(client.auth);
@@ -289,7 +292,10 @@ function setBetterSupabase(client, options = {}) {
 	if (queryClient) onMount(() => clearOnUserChange(queryClient, client.auth));
 	return setContext(CLIENT, bound);
 }
-/** The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof bs>()`. */
+/**
+* The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof
+* bs>()`.
+*/
 function getBetterSupabase() {
 	const bound = getContext(CLIENT);
 	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
@@ -328,11 +334,17 @@ function usePresence(topic, values, options) {
 function useAction(action, options) {
 	return getBetterSupabase().action(action, options);
 }
-/** Shares a server-verified session (from `+layout.ts` data) with the components below. */
+/**
+* Shares a server-verified session (from `+layout.ts` data) with the components
+* below.
+*/
 function setSession(session) {
 	setContext(SESSION, session);
 }
-/** The session from the nearest `setSession()`, typed with `useSession<Claims, Profile>()`. */
+/**
+* The session from the nearest `setSession()`, typed with `useSession<Claims,
+* Profile>()`.
+*/
 function useSession() {
 	const session = getContext(SESSION);
 	if (!session) throw new Error("better-supabase: useSession() needs setSession(() => data.session) in a parent component");

package/dist/svelte-controller-BmRhHvFz.js

@@ -0,0 +1,50 @@
+import { t as CLIENT } from "./context-C-bHOtoD.js";
+import { n as withEnv, t as blockEnv } from "./block-env-YfPmSNa1.js";
+import { getContext, onDestroy, onMount } from "svelte";
+import { readable } from "svelte/store";
+//#region src/blocks/svelte-controller.ts
+function contextClient() {
+	const bound = getContext(CLIENT);
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
+	return bound.client;
+}
+/**
+* Makes a controller once, during component setup. The store follows it from
+* mount (never during server rendering) while it has subscribers, and the
+* controller is disposed with the component.
+*/
+function useBlockController(create, options, usesEnv = true) {
+	const controller = create(withEnv(options, usesEnv ? () => blockEnv(contextClient()) : void 0));
+	let mounted = false;
+	let pending;
+	const store = readable(controller.getSnapshot(), (set) => {
+		let stop;
+		const start = () => {
+			stop = controller.subscribe(() => {
+				set(controller.getSnapshot());
+			});
+			set(controller.getSnapshot());
+		};
+		if (mounted) start();
+		else pending = start;
+		return () => {
+			pending = void 0;
+			stop?.();
+		};
+	});
+	onMount(() => {
+		mounted = true;
+		pending?.();
+		pending = void 0;
+	});
+	onDestroy(() => {
+		controller.dispose();
+	});
+	return {
+		subscribe: store.subscribe,
+		actions: controller.actions,
+		controller
+	};
+}
+//#endregion
+export { useBlockController as t };

package/dist/svelte-controller-DXO7gsmS.d.ts

@@ -0,0 +1,13 @@
+import { n as Controller } from "./controller-lWRcKqCl.js";
+import { Readable } from "svelte/store";
+//#region src/blocks/svelte-controller.d.ts
+/**
+ * A block controller in a Svelte component: a readable store of its state, with
+ * its actions.
+ */
+interface SvelteController<S, A> extends Readable<S> {
+  readonly actions: A;
+  readonly controller: Controller<S, A>;
+}
+//#endregion
+export { SvelteController as t };

package/dist/sveltekit/index.d.ts

@@ -1,11 +1,11 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-BrpW5ixT.js";
-import { t as BetterSupabase } from "../define-DYZnvAbs.js";
-import { n as BetterServer } from "../server-types-fLdep4gb.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-De-EVRhw.js";
-import { t as RefusalRedirects } from "../refusal-C7geIBRl.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-BQhTsLX-.js";
-import { t as Validated } from "../shared-DDSjEGDR.js";
-import { i as tagFor } from "../tags-BrGopDVG.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
+import { t as BetterSupabase } from "../define-D0LSXmUP.js";
+import { n as BetterServer } from "../server-types-D_cQ6OxZ.js";
+import { a as AuthorizedContext, c as ResourceLoaderContext, i as AuthorizeOptions, l as Unwrapped, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-LeQGMzLH.js";
+import { t as RefusalRedirects } from "../refusal-BEyNVFy7.js";
+import { n as FrameworkOptions, r as LocalsResource, t as FrameworkLocals } from "../framework-CMeAuJts.js";
+import { t as Validated } from "../shared-CRRfQAKG.js";
+import { i as tagFor } from "../tags-tbiuHHMV.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/bridges/sveltekit.d.ts
@@ -17,19 +17,23 @@ interface SvelteKitEvent<Locals extends object> {
     readonly env?: unknown;
   } | undefined;
 }
-/** SvelteKit's `Handle`, typed structurally so the package does not import `@sveltejs/kit`. */
+/**
+ * SvelteKit's `Handle`, typed structurally so the package does not import
+ * `@sveltejs/kit`.
+ */
 type SvelteKitHandle<Locals extends object> = <Event extends SvelteKitEvent<Locals>>(input: {
   readonly event: Event;
   readonly resolve: (event: Event) => Response | Promise<Response>;
 }) => Promise<Response>;
 /**
- * Runs an entry array as a SvelteKit `handle` hook. Every contributed key
- * lands on `event.locals`, so loads, actions and endpoints read
- * `locals.db`; `event.platform.env` (Cloudflare) seeds `getEnv`. Declare
- * the keys in `App.Locals` with `BetterSupabaseContributions`.
+ * Runs an entry array as a SvelteKit `handle` hook. Every contributed key lands
+ * on `event.locals`, so loads, actions and endpoints read `locals.db`;
+ * `event.platform.env` (Cloudflare) seeds `getEnv`. Declare the keys in
+ * `App.Locals` with `BetterSupabaseContributions`.
  *
- * ```ts title="src/hooks.server.ts"
- * export const handle = toSvelteKit([withBetterSupabase(server)])
+ * ```ts
+ * // src/hooks.server.ts
+ * export const handle = toSvelteKit([withBetterSupabase(server)]);
  * ```
  *
  * Compose it with other hooks through SvelteKit's `sequence`.
@@ -44,8 +48,8 @@ interface SvelteKitFailure<T> {
 }
 /**
  * `error`, `redirect` and `fail` from `@sveltejs/kit`. Pass them so refused
- * callers get SvelteKit's own errors and redirects, and failed form actions
- * a `fail()` with the status.
+ * callers get SvelteKit's own errors and redirects, and failed form actions a
+ * `fail()` with the status.
  */
 interface SvelteKitHelpers {
   error(status: number, message: string): never;
@@ -71,44 +75,52 @@ interface SvelteKitAppError {
   readonly code?: string;
 }
 interface BetterSvelteKit<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> extends BetterServer<M, F, E, C, P, B> {
-  /** The keys on `event.locals`, for `App.Locals`. Type only: `undefined` at runtime. */
+  /**
+   * The keys on `event.locals`, for `App.Locals`. Type only: `undefined` at
+   * runtime.
+   */
   readonly Locals: FrameworkLocals<M, F, E, C, P, B>;
   /**
    * The `handle` hook: verifies the caller, refreshes the session cookie on
-   * navigations and form posts, and puts `db`, `bs`, `auth`, `tenant` and
-   * the serializable `session` on `event.locals`.
+   * navigations and form posts, and puts `db`, `bs`, `auth`, `tenant` and the
+   * serializable `session` on `event.locals`.
    */
   readonly handle: SvelteKitHandle<Partial<FrameworkLocals<M, F, E, C, P, B>>>;
   /**
-   * The caller in a `load` or endpoint, or a refusal: a redirect to
-   * `signIn` or `mfa` when configured, else SvelteKit's `error()`.
+   * The caller in a `load` or endpoint, or a refusal: a redirect to `signIn` or
+   * `mfa` when configured, else SvelteKit's `error()`.
    *
    * ```ts
    * export const load = async (event) => {
-   *   const { db, tenant } = await bs.require(event, { requireTenant: true });
+   *   const { db, tenant } = await bs.require(event, {
+   *     requireTenant: true,
+   *   });
    *   return { customers: await db.customers.findMany().orThrow() };
    * };
    * ```
    */
-  require<R extends boolean = false>(event: SvelteKitRequestEvent, options?: BlockRequireOptions<C, P, R>): Promise<FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>>;
+  require<R extends boolean = false>(event: SvelteKitRequestEvent, options?: BlockRequireOptions<C, P, R, unknown, LocalsResource<M, F, E, C, P, B>>): Promise<FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>>;
   /**
-   * A form action returning an `ActionResult`: validates the form with
-   * `input`, runs the guard and `authorize`, and on failure answers with
-   * `fail(status, result)` when `kit` is set, so `form.error` is a `DbError`.
+   * A form action returning an `ActionResult`: validates the form with `input`,
+   * runs the guard and `authorize`, and on failure answers with `fail(status,
+   * result)` when `kit` is set, so `form.error` is a `DbError`.
    */
-  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>, event: SvelteKitRequestEvent) => T): (event: SvelteKitRequestEvent) => Promise<ActionResult<Unwrapped<Awaited<T>>> | SvelteKitFailure<ActionResult<never>>>;
+  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R, unknown, LocalsResource<M, F, E, C, P, B>>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>, event: SvelteKitRequestEvent) => T): (event: SvelteKitRequestEvent) => Promise<ActionResult<Unwrapped<Awaited<T>>> | SvelteKitFailure<ActionResult<never>>>;
   /**
-   * `handleError` for `hooks.server.ts`: `DbError`s keep their message and
-   * kind as `code`; other errors become a generic message unless
-   * `exposeErrors` is on.
+   * `handleError` for `hooks.server.ts`: `DbError`s keep their message and kind
+   * as `code`; other errors become a generic message unless `exposeErrors` is
+   * on.
    */
   handleError(input: {
     readonly error: unknown;
   }): SvelteKitAppError;
-  /** Registers `bs:<table>` dependencies, so `invalidate(tagFor(table))` reruns the load. */
+  /**
+   * Registers `bs:<table>` dependencies, so `invalidate(tagFor(table))` reruns
+   * the load.
+   */
   depends(load: SvelteKitDepends, ...tables: readonly string[]): void;
 }
 /** SvelteKit integration: a `handle` hook, guarded loads and form actions. */
 export declare function createSvelteKit<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P, B>, options?: SvelteKitOptions): BetterSvelteKit<M, F, E, C, P, B>;
 //#endregion
-export { type ActionResult, type AuthorizeOptions, type AuthorizedContext, type BetterSvelteKit, type BlockActionOptions, type BlockRequireOptions, type FrameworkLocals, type FrameworkOptions, type RefusalRedirects, type SvelteKitAppError, type SvelteKitDepends, type SvelteKitEvent, type SvelteKitFailure, type SvelteKitHandle, type SvelteKitHelpers, type SvelteKitOptions, type SvelteKitRequestEvent, tagFor };
+export { type ActionResult, type AuthorizeOptions, type AuthorizedContext, type BetterSvelteKit, type BlockActionOptions, type BlockRequireOptions, type FrameworkLocals, type FrameworkOptions, type RefusalRedirects, type ResourceLoaderContext, type SvelteKitAppError, type SvelteKitDepends, type SvelteKitEvent, type SvelteKitFailure, type SvelteKitHandle, type SvelteKitHelpers, type SvelteKitOptions, type SvelteKitRequestEvent, tagFor };

package/dist/sveltekit/index.js

@@ -1,22 +1,23 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { r as dbErrorOf } from "../errors-BV1SKTVs.js";
-import { c as toProblem } from "../problem-JRCohp1j.js";
-import { c as extendServer, o as withFlush, s as createServer } from "../adapter-CRNH2aX_.js";
-import { t as defaultExpose } from "../respond-Bhp3G__q.js";
-import { r as tagFor } from "../tags-B99_U9Pp.js";
-import { i as requireCaller, o as runAction } from "../kit-LTbHrWWD.js";
-import { n as bufferInPlace, t as around } from "../shared-BmMcMoW9.js";
-import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-C6PKBgme.js";
-import { i as refusalTarget } from "../refusal-CFpfmjcS.js";
+import { r as dbErrorOf } from "../errors-D7u24ZJH.js";
+import { c as toProblem } from "../problem-D0KDiYPk.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-D8dW6p2A.js";
+import { t as defaultExpose } from "../respond-DjEmE_DN.js";
+import { r as tagFor } from "../tags-C_ym1yDM.js";
+import { i as requireCaller, o as runAction } from "../kit-BeXTrlZn.js";
+import { n as bufferInPlace, t as around } from "../shared-Bf-I13Ht.js";
+import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-BpEnOfAo.js";
+import { i as refusalTarget } from "../refusal-Ce2p81VW.js";
 //#region src/bridges/sveltekit.ts
 /**
-* Runs an entry array as a SvelteKit `handle` hook. Every contributed key
-* lands on `event.locals`, so loads, actions and endpoints read
-* `locals.db`; `event.platform.env` (Cloudflare) seeds `getEnv`. Declare
-* the keys in `App.Locals` with `BetterSupabaseContributions`.
+* Runs an entry array as a SvelteKit `handle` hook. Every contributed key lands
+* on `event.locals`, so loads, actions and endpoints read `locals.db`;
+* `event.platform.env` (Cloudflare) seeds `getEnv`. Declare the keys in
+* `App.Locals` with `BetterSupabaseContributions`.
 *
-* ```ts title="src/hooks.server.ts"
-* export const handle = toSvelteKit([withBetterSupabase(server)])
+* ```ts
+* // src/hooks.server.ts
+* export const handle = toSvelteKit([withBetterSupabase(server)]);
 * ```
 *
 * Compose it with other hooks through SvelteKit's `sequence`.
@@ -65,7 +66,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 		handle,
 		require: async (event, requireOptions = {}) => {
 			const locals = localsFrom(event);
-			const caller = await requireCaller(locals.bs.auth, requireOptions, locals.tenant, options.authorizer);
+			const caller = await requireCaller(locals.bs.auth, requireOptions, locals.tenant, options.authorizer, locals);
 			if ("kind" in caller) return refuse(caller, event.request);
 			return {
 				...locals,
@@ -79,7 +80,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 				const result = await runAction(locals.bs.auth, actionOptions, input, locals.tenant, (parsed, caller) => fn(parsed, {
 					...locals,
 					...caller
-				}, event), options.authorizer);
+				}, event), options.authorizer, locals);
 				if (!result.ok && options.kit) return options.kit.fail(result.error.status, result);
 				return result;
 			};

package/dist/table-schema-xqSXrjCN.js

@@ -0,0 +1,284 @@
+import { i as isPlainDateTime, n as isInstant } from "./temporal-DLZlWbOi.js";
+import { n as isRecord, 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#"
+};
+/**
+* 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" && isRecord(value)) out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, isRecord(child) ? toOpenApi30(child) : child]));
+	else if (key === "items" && isRecord(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 (isRecord(inner) && isRecord(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 (!isRecord(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;
+	}
+	for (const [index, item] of value.entries()) 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 (!isRecord(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-C_ym1yDM.js

@@ -0,0 +1,39 @@
+//#region src/core/tags.ts
+/**
+* `bs:<table>`, `bs:<table>:<id>`, or `bs:<table>@<tenant>` for a read scoped
+* to one tenant. Mutations invalidate the table tag, the tag of their tenant
+* (`bs:<table>@*` without one) and the tags of the changed rows.
+*/
+function tagFor(table, id, options = {}) {
+	if (id !== void 0) return `bs:${table}:${String(id)}`;
+	return options.tenant === void 0 ? `bs:${table}` : `bs:${table}@${options.tenant}`;
+}
+/**
+* The tags a mutation invalidates: `bs:<table>` for every table in the target,
+* the tenant's `bs:<table>@<tenant>` (every tenant's `bs:<table>@*` when the
+* mutation has no tenant) and `bs:<table>:<id>` per changed row.
+*/
+function cacheTagsOf(target) {
+	const tenant = { tenant: target.tenant ?? "*" };
+	const tags = [];
+	for (const table of target.tables) tags.push(tagFor(table), tagFor(table, void 0, tenant));
+	for (const id of target.ids) tags.push(tagFor(target.table, id));
+	return tags;
+}
+/**
+* A `CacheAdapter` for any tag-based cache: it hands `invalidate` the tags from
+* `cacheTagsOf`, e.g. a CDN purge by tag, SvelteKit's `invalidate`, or a Redis
+* set of keys per tag. Tag your reads with `tagFor`.
+*
+* ```ts
+* betterSupabase.cache(tagCache((tags) => purgeCdn(tags), "cdn"));
+* ```
+*/
+function tagCache(invalidate, name = "tags") {
+	return {
+		name,
+		invalidate: (target) => invalidate(cacheTagsOf(target))
+	};
+}
+//#endregion
+export { tagCache as n, tagFor as r, cacheTagsOf as t };