better-supabase 0.14.0 → 0.15.0

package/dist/subjects-BpIEN1MS.d.ts

@@ -0,0 +1,90 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "./result-DZeA5KS6.js";
+import { $ as RecordRef } from "./types-DFdg_4yN.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-CRpAHrp_.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+//#region src/blocks/subjects/my-work-kinds.d.ts
+/** What a `my_work` item waits on. */
+type MyWorkKind = "assigned" | "approval" | "reminder" | "mention" | "sla";
+/** The kinds `my_work` returns, in the order the docs list them. */
+declare const MY_WORK_KINDS: readonly MyWorkKind[];
+//#endregion
+//#region src/blocks/subjects/subjects.d.ts
+/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
+declare const SUBJECT_TITLES_LIMIT = 500;
+interface SubjectsOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Subjects>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A subject with its title and path, from `config.records`. */
+interface ResolvedSubject extends RecordRef {
+  /** The `title` column's value, when the type names one. */
+  readonly title?: string;
+  /** The `url` template filled in, such as `/customers/42`. */
+  readonly url?: string;
+}
+/** A record page's header and tab badges, from `record_summary`. */
+interface RecordSummary extends ResolvedSubject {
+  /** Rows per section the caller can read, for each installed section asked. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** Per section, whether a row is newer than `seenAt`. */
+  readonly unread: Readonly<Record<string, boolean>>;
+}
+interface RecordSummaryOptions {
+  /** When the caller last saw the record; every section is read without it. */
+  readonly seenAt?: Temporal.Instant | null;
+}
+/** One thing waiting on the caller, from `my_work`. */
+interface MyWorkItem {
+  readonly kind: MyWorkKind;
+  /** The record it is about: the work item, or the approval's subject. */
+  readonly subject: RecordRef;
+  /**
+   * The row that put it here: the work item, approval request, reminder,
+   * comment or SLA clock id.
+   */
+  readonly ref: string;
+  readonly title?: string;
+  readonly url?: string;
+  /** The due date, or when it arrived. */
+  readonly at?: Temporal.Instant;
+}
+/** The most items one `my_work` call returns. */
+declare const MY_WORK_LIMIT = 200;
+interface MyWorkOptions {
+  /** Only this organization's work. Default: every organization. */
+  readonly tenant?: string;
+  /** At most this many items, newest first. Default 50, at most 200. */
+  readonly pageSize?: number;
+}
+/** The subjects block's registry as typed calls. */
+interface Subjects {
+  /**
+   * Titles and paths for many subjects in one call, keyed by `subjectKey`
+   * (`type:id`). A subject the caller can't read, a soft-deleted row or an
+   * unknown type is left out.
+   */
+  resolve(refs: readonly RecordRef[]): AsyncResult<Readonly<Record<string, ResolvedSubject>>>;
+  /**
+   * The subject's title and path with a count and unread state for each of
+   * `sections` (`comments`, `attachments`), in one round trip; `undefined` when
+   * the caller can't read the subject.
+   */
+  summary(subject: RecordRef, sections: readonly string[], options?: RecordSummaryOptions): AsyncResult<RecordSummary | undefined>;
+  /**
+   * What waits on the caller across the installed blocks, newest first: open
+   * work items assigned to them, approvals they can decide, their reminders
+   * sent this week, recent mentions and SLA clocks warned on their work.
+   */
+  myWork(options?: MyWorkOptions): AsyncResult<readonly MyWorkItem[]>;
+}
+/**
+ * The `subjects` module's `subject_titles` as a typed call, for lists and
+ * mentions that show a link to each subject.
+ */
+declare function createSubjects(options: SubjectsOptions): Subjects;
+//#endregion
+export { RecordSummaryOptions as a, Subjects as c, MY_WORK_KINDS as d, MyWorkKind as f, RecordSummary as i, SubjectsOptions as l, MyWorkItem as n, ResolvedSubject as o, MyWorkOptions as r, SUBJECT_TITLES_LIMIT as s, MY_WORK_LIMIT as t, createSubjects as u };

package/dist/subjects-DvmQeF_F.d.ts

@@ -0,0 +1,79 @@
+//#region src/config/types/subjects.d.ts
+/**
+ * One entity the app's blocks attach to (`subjects.<type>`): a task, a
+ * customer, a document. Every subject-bound SQL module reads these entries
+ * unless its own `on` says otherwise. ADR 0020.
+ */
+interface SubjectConfig {
+  /** `schema.table`, or a table in `public`. */
+  readonly table: string;
+  /** The id column. Defaults to `id`. */
+  readonly id?: string;
+  /**
+   * The id column's type, such as `uuid` or `bigint`, so lookups compare on the
+   * primary key's own type. Without it the column is compared as text.
+   */
+  readonly idType?: string;
+  /**
+   * The tenant column. Defaults to `organization_id`, or
+   * `<blocks.memberships.names.organization>_id` when the tenant is renamed.
+   * `false` for a subject without a tenant, which modules that keep a tenant on
+   * every row skip.
+   */
+  readonly tenant?: string | false;
+  /** The column `subject_title` returns. */
+  readonly title?: string;
+  /**
+   * The path `subject_url` returns, with `{column}` placeholders:
+   * `/tasks/{id}`.
+   */
+  readonly url?: string;
+  /**
+   * A permission key per action (`read`, `write`, or an app action) that
+   * `can_subject` checks in the subject's tenant, on top of the row being
+   * visible to the caller. `read` is also the permission modules check before
+   * they attach rows to the subject.
+   */
+  readonly permissions?: Readonly<Record<string, string>>;
+  /**
+   * A scope the authorization provider declares whose ids are this subject's
+   * ids, so a grant on the record counts as well as one on the tenant.
+   */
+  readonly scope?: string;
+  /** Delete module rows for a subject when its row is deleted. */
+  readonly cascade?: boolean;
+  /**
+   * The column holding the soft-delete time. Blocks hide rows where it is set,
+   * metrics skip them, and `gen` makes it the table's `trashExtension()`
+   * column.
+   */
+  readonly deletedAt?: string;
+  /** The columns a search index reads. */
+  readonly search?: {
+    readonly title?: string;
+    readonly body?: readonly string[];
+  };
+  /**
+   * The text column holding the subject's rank key, and the column it is
+   * grouped by (a board stage), for `move()`. ADR 0021.
+   */
+  readonly rank?: {
+    readonly column: string;
+    readonly group?: string;
+  };
+  /**
+   * The columns the versions block snapshots and restores, and whether it
+   * snapshots on each change. An app table's `subject.versions` sets it.
+   */
+  readonly versions?: {
+    readonly columns: readonly string[];
+    readonly auto: boolean;
+  };
+}
+/**
+ * The app's subject types, keyed by type name (lowercase, digits and
+ * underscores).
+ */
+type SubjectsConfig = Readonly<Record<string, SubjectConfig>>;
+//#endregion
+export { SubjectsConfig as n, SubjectConfig as t };

package/dist/support-view-BYOgwXsJ.d.ts

@@ -0,0 +1,17 @@
+import { t as AuthSession } from "./view-DyFdMCqg.js";
+//#region src/auth/support-view.d.ts
+/** A running support session as the target's view shows it, for a banner. */
+interface SupportView {
+  readonly sessionId: string;
+  /** The admin viewing the app. */
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly reason?: string;
+  readonly readOnly: boolean;
+  /** Seconds since epoch. */
+  readonly expiresAt: number | null;
+}
+/** The support session behind `session`, or `undefined` outside one. */
+declare function supportOf(session: AuthSession): SupportView | undefined;
+//#endregion
+export { supportOf as n, SupportView as t };

package/dist/svelte/index.d.ts

@@ -1,15 +1,27 @@
-import { b as DbError } from "../result-C6jDfedy.js";
-import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, k as BlockEventsMatching } from "../events-DbLjvxDX.js";
-import { J as QuerySpec } from "../define-Dw7pRO4h.js";
-import { $ as TemplateValues } from "../bucket-TkB7_xv8.js";
-import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-D9j8G2dw.js";
-import { t as AuthSnapshot } from "../bind-Dz8y3T5T.js";
-import { t as AuthSession } from "../view-2_I-2ukO.js";
-import { _ as LiveQueryHookOptions, a as BlockQueryActions, b as ProfileOf, c as BlockRefetchOn, d as ActionState, f as BroadcastOptions, g as LiveCountSource, h as LiveCountHookOptions, i as BlockMutationState, l as ActionInputOf, m as ClientLike, n as BlockEventSource, o as BlockQueryOptions, p as ClaimsOf, r as BlockMutationActions, s as BlockQueryState, t as fieldErrorsOf, u as ActionResultOf, v as PresenceHookOptions, x as UseActionOptions, y as PresenceTopic } from "../field-errors-vshYTVKr.js";
-import { t as SvelteController } from "../svelte-bind-Ja6CtQGp.js";
-import { i as BlockMethodName, n as BlockDataOf, t as BlockArgsOf } from "../block-method-hsPAGFi5.js";
+import { b as DbError } from "../result-DZeA5KS6.js";
+import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, k as BlockEventsMatching } from "../events-vcqenSYU.js";
+import { pt as QuerySpec } from "../define-DFBnQyYg.js";
+import { $ as TemplateValues } from "../bucket-CiNi8sIw.js";
+import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-CJrQZQaa.js";
+import { t as AuthSnapshot } from "../bind-CrMBwrPN.js";
+import { t as AuthSession } from "../view-DyFdMCqg.js";
+import { n as Controller } from "../controller-BrP0gn47.js";
+import { C as LiveCountSource, D as ProfileOf, E as PresenceTopic, O as UseActionOptions, S as LiveCountHookOptions, T as PresenceHookOptions, _ as ActionResultOf, a as DataRows, b as ClaimsOf, c as DataWrites, d as BlockMutationState, f as BlockQueryActions, g as ActionInputOf, h as BlockRefetchOn, i as DataRow, l as BlockEventSource, m as BlockQueryState, n as DataId, o as DataSource, p as BlockQueryOptions, r as DataListArgs, s as DataState, t as fieldErrorsOf, u as BlockMutationActions, v as ActionState, w as LiveQueryHookOptions, x as ClientLike, y as BroadcastOptions } from "../field-errors-fsbFktYF.js";
+import { n as BlockOptions } from "../block-env-B_uEM2xz.js";
+import { n as BlockDataOf, r as BlockMethodName, t as BlockArgsOf } from "../block-method-CiVa2G-J.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { QueryClient } from "@tanstack/query-core";
+import { Readable } from "svelte/store";
+//#region src/blocks/svelte-bind.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
 //#region src/svelte/block-hooks.d.ts
 /**
  * Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
@@ -25,6 +37,31 @@ export declare function useBlockMutation<C extends object, const K extends Block
  */
 export declare function useBlockEvent<M extends EventMap, const P extends BlockEventPattern<M>>(source: BlockEventSource, events: Events<M>, pattern: P, handler: (event: BlockEvent<M, BlockEventsMatching<M, P>>) => void): void;
 //#endregion
+//#region src/blocks/svelte-controller.d.ts
+/**
+ * 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.
+ */
+export declare function useBlockController<O, S, A>(create: (options: O) => Controller<S, A>, options: BlockOptions<O>, usesEnv?: boolean): SvelteController<S, A>;
+//#endregion
+//#region src/svelte/data-hooks.d.ts
+/** What `useList` and `useOne` return: a store of the read, with the writes. */
+type DataView<S extends DataSource, T> = SvelteController<DataState<T>, DataWrites<S>>;
+/** The stores `defineDataHooks` makes for one table or block instance. */
+interface DataHooks<S extends DataSource> {
+  /** `source.list(args)`, kept fresh after every write. */
+  readonly useList: (args?: DataListArgs<S>) => DataView<S, DataRows<S>>;
+  /** `source.get(id)`, kept fresh after every write. */
+  readonly useOne: (id: DataId<S>) => DataView<S, DataRow<S>>;
+}
+/**
+ * The list and record stores for one table or block instance. Call them during
+ * component setup. The generated `hooks.ts` calls it once per table; `select`
+ * picks the source from the bound client's `db`.
+ */
+export declare function defineDataHooks<D, S extends DataSource>(name: string, select: (db: D) => S): DataHooks<S>;
+//#endregion
 //#region src/svelte/index.d.ts
 /**
  * A value read through `.current`, reactive in templates, `$derived` and
@@ -69,7 +106,7 @@ export interface BetterSvelte<B extends ClientLike = ClientLike> {
   readonly db: B["db"];
   /**
    * TanStack Query option factories: `createQuery(() =>
-   * bs.queries.customers.findMany())`.
+   * bsb.queries.customers.list())`.
    */
   readonly queries: B["queries"];
   readonly supabase: SupabaseClient;
@@ -96,14 +133,14 @@ export declare function createBetterSvelte<B extends ClientLike>(client: B, opti
  *
  * ```svelte
  * <script lang="ts">
- *   setBetterSupabase(bs, { queryClient });
+ *   setBetterSupabase(bsb, { queryClient });
  * <\/script>
  * ```
  */
 export declare function setBetterSupabase<B extends ClientLike>(client: B, options?: BetterSvelteOptions): BetterSvelte<B>;
 /**
  * The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof
- * bs>()`.
+ * bsb>()`.
  */
 export declare function getBetterSupabase<B extends ClientLike = ClientLike>(): BetterSvelte<B>;
 /** The session state for UI. Call during component setup. */
@@ -115,7 +152,7 @@ export declare function useBroadcast<P extends string, E extends EventSchemas>(t
  *
  * ```svelte
  * <script lang="ts">
- *   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+ *   const live = useLiveQuery(() => betterSupabase.spec.customers.list());
  * <\/script>
  * <span data-status={live.current}></span>
  * ```
@@ -138,4 +175,4 @@ export declare function setSession(session: () => AuthSession): void;
  */
 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 BlockEventSource, type BlockMutationActions, type BlockMutationState, type BlockQueryActions, type BlockQueryOptions, type BlockQueryState, type BlockRefetchOn, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type UseActionOptions, fieldErrorsOf };
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BlockEventSource, type BlockMutationActions, type BlockMutationState, type BlockOptions, type BlockQueryActions, type BlockQueryOptions, type BlockQueryState, type BlockRefetchOn, type BroadcastOptions, type ClaimsOf, type ClientLike, type DataHooks, type DataSource, type DataState, type DataView, type DataWrites, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type SvelteController, type UseActionOptions, fieldErrorsOf };

package/dist/svelte/index.js

@@ -1,9 +1,52 @@
-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-C_0XZieg.js";
-import { a as fieldErrorsOf, i as listenToBlockEvents, n as createBlockMutation, r as createBlockQuery } from "../block-controller-DTGuBemi.js";
-import { n as CLIENT, t as bindSvelteController } from "../svelte-bind-BHN5a8VV.js";
-import { getContext, onMount, setContext } from "svelte";
+import { t as clearOnUserChange } from "../user-change-DgWC6RRC.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-BAEbEA7t.js";
+import { c as listenToBlockEvents, d as fieldErrorsOf, i as dataTarget, l as blockEnv, n as createDataOne, o as createBlockMutation, s as createBlockQuery, t as createDataList, u as withEnv } from "../data-hooks-tgF1Ct0F.js";
+import { getContext, onDestroy, onMount, setContext } from "svelte";
 import { createSubscriber } from "svelte/reactivity";
+import { readable } from "svelte/store";
+//#region src/svelte/context.ts
+/** The context key `setBetterSupabase` binds the client under. */
+const CLIENT = Symbol("better-supabase");
+//#endregion
+//#region src/blocks/svelte-bind.ts
+/**
+* Wraps a controller made 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 bindSvelteController(controller) {
+	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
 //#region src/svelte/block-hooks.ts
 /**
 * Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
@@ -25,6 +68,39 @@ function useBlockEvent(source, events, pattern, handler) {
 	onMount(() => listenToBlockEvents(source, events, pattern, () => handler));
 }
 //#endregion
+//#region src/blocks/svelte-controller.ts
+function contextClient() {
+	const bound = getContext(CLIENT);
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bsb) 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) {
+	return bindSvelteController(create(withEnv(options, usesEnv ? () => blockEnv(contextClient()) : void 0)));
+}
+//#endregion
+//#region src/svelte/data-hooks.ts
+function client() {
+	const bound = getContext(CLIENT);
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bsb) in a parent component");
+	return bound.client;
+}
+/**
+* The list and record stores for one table or block instance. Call them during
+* component setup. The generated `hooks.ts` calls it once per table; `select`
+* picks the source from the bound client's `db`.
+*/
+function defineDataHooks(name, select) {
+	return {
+		useList: (args) => bindSvelteController(createDataList(dataTarget(client(), name, select), args)),
+		useOne: (id) => bindSvelteController(createDataOne(dataTarget(client(), name, select), id))
+	};
+}
+//#endregion
 //#region src/svelte/index.ts
 /** Reads a store reactively: the caller re-runs when the store changes. */
 function reactive(store) {
@@ -133,7 +209,7 @@ function createBetterSvelte(client, options = {}) {
 			let joined = null;
 			const track = followed(() => {
 				const current = spec();
-				if (current && !queryClient) throw new Error("better-supabase: liveQuery needs setBetterSupabase(bs, { queryClient })");
+				if (current && !queryClient) throw new Error("better-supabase: liveQuery needs setBetterSupabase(bsb, { queryClient })");
 				return liveKey(client, current, auth.current, options);
 			}, (key, notify) => {
 				const current = spec();
@@ -303,7 +379,7 @@ const SESSION = Symbol("better-supabase-session");
 *
 * ```svelte
 * <script lang="ts">
-*   setBetterSupabase(bs, { queryClient });
+*   setBetterSupabase(bsb, { queryClient });
 * <\/script>
 * ```
 */
@@ -315,11 +391,11 @@ function setBetterSupabase(client, options = {}) {
 }
 /**
 * The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof
-* bs>()`.
+* bsb>()`.
 */
 function getBetterSupabase() {
 	const bound = getContext(CLIENT);
-	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bsb) in a parent component");
 	return bound;
 }
 /** The session state for UI. Call during component setup. */
@@ -335,7 +411,7 @@ function useBroadcast(topic, values, handlers, options) {
 *
 * ```svelte
 * <script lang="ts">
-*   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+*   const live = useLiveQuery(() => betterSupabase.spec.customers.list());
 * <\/script>
 * <span data-status={live.current}></span>
 * ```
@@ -374,4 +450,4 @@ function useSession() {
 	} };
 }
 //#endregion
-export { createBetterSvelte, fieldErrorsOf, getBetterSupabase, setBetterSupabase, setSession, useAction, useAuth, useBlockEvent, useBlockMutation, useBlockQuery, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession };
+export { createBetterSvelte, defineDataHooks, fieldErrorsOf, getBetterSupabase, setBetterSupabase, setSession, useAction, useAuth, useBlockController, useBlockEvent, useBlockMutation, useBlockQuery, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession };

package/dist/sveltekit/index.d.ts

@@ -1,12 +1,12 @@
-import { M as AnyFunctions, N as AnyModels } from "../executor-CPyrQdjh.js";
-import { s as PermissionRef, t as AnyAuthorizer } from "../authorizer-DFP3gHv8.js";
-import { t as BetterSupabase } from "../define-Dw7pRO4h.js";
-import { n as BetterServer } from "../server-types-BOs-eFpo.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-DKfbNTAA.js";
-import { t as RefusalRedirects } from "../refusal-efy5bZMd.js";
-import { n as FrameworkOptions, r as LocalsResource, t as FrameworkLocals } from "../framework-FxfJpyoF.js";
+import { O as AnyFunctions, k as AnyModels } from "../types-DFdg_4yN.js";
+import { l as PermissionRef, t as AnyAuthorizer } from "../authorizer-B6X09otb.js";
+import { t as BetterSupabase } from "../define-DFBnQyYg.js";
+import { n as BetterServer } from "../server-types-CFtehAsr.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-DOwKpSkA.js";
+import { t as RefusalRedirects } from "../refusal-CSntB_x8.js";
+import { n as FrameworkOptions, r as LocalsResource, t as FrameworkLocals } from "../framework-BKyTeS-j.js";
 import { t as Validated } from "../shared-CRRfQAKG.js";
-import { i as tagFor } from "../tags-CLXi2c6O.js";
+import { i as tagFor } from "../tags-BjHflcHF.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/bridges/sveltekit.d.ts
@@ -83,7 +83,7 @@ interface BetterSvelteKit<M extends AnyModels, F extends AnyFunctions, E, C = un
   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
+   * navigations and form posts, and puts `db`, `bsb`, `auth`, `tenant` and the
    * serializable `session` on `event.locals`.
    */
   readonly handle: SvelteKitHandle<Partial<FrameworkLocals<M, F, E, C, P, B>>>;
@@ -93,10 +93,10 @@ interface BetterSvelteKit<M extends AnyModels, F extends AnyFunctions, E, C = un
    *
    * ```ts
    * export const load = async (event) => {
-   *   const { db, tenant } = await bs.require(event, {
-   *     requireTenant: true,
+   *   const { db, tenant } = await bsb.require(event, {
+   *     requireOrganization: true,
    *   });
-   *   return { customers: await db.customers.findMany().orThrow() };
+   *   return { customers: await db.customers.list().orThrow() };
    * };
    * ```
    */
@@ -116,7 +116,7 @@ interface BetterSvelteKit<M extends AnyModels, F extends AnyFunctions, E, C = un
     readonly error: unknown;
   }): SvelteKitAppError;
   /**
-   * Registers `bs:<table>` dependencies, so `invalidate(tagFor(table))` reruns
+   * Registers `bsb:<table>` dependencies, so `invalidate(tagFor(table))` reruns
    * the load.
    */
   depends(load: SvelteKitDepends, ...tables: readonly string[]): void;

package/dist/sveltekit/index.js

@@ -1,13 +1,13 @@
 import { t as DbException } from "../db-exception-Lngc1W49.js";
-import { r as dbErrorOf } from "../errors-03ysrOt4.js";
-import { c as toProblem } from "../problem-BWElIgIb.js";
-import { c as extendServer, o as withFlush, s as createServer } from "../adapter-BCFAg58A.js";
-import { t as defaultExpose } from "../respond-z_yfyitp.js";
-import { r as tagFor } from "../tags-C_ym1yDM.js";
-import { i as requireCaller, o as runAction } from "../kit-Ct4Z6GIO.js";
+import { r as dbErrorOf } from "../errors-BVFgt8BZ.js";
+import { c as toProblem } from "../problem-Bf0cJ7tk.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-B0b6MXYS.js";
+import { t as defaultExpose } from "../respond-C3CcOZlA.js";
+import { r as tagFor } from "../tags-CIZTqtlY.js";
+import { i as requireCaller, o as runAction } from "../kit-5l-o8RxL.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-CXoyWGgd.js";
-import { i as refusalTarget } from "../refusal-DXydjgsS.js";
+import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-DDdkR7FX.js";
+import { i as refusalTarget } from "../refusal-ByBZcm0V.js";
 //#region src/bridges/sveltekit.ts
 /**
 * Runs an entry array as a SvelteKit `handle` hook. Every contributed key lands
@@ -41,7 +41,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 	const run = around([frameworkEntry(server, options, expose)]);
 	const localsFrom = (event) => {
 		const locals = event.locals;
-		if (!locals.bs) throw new TypeError("better-supabase: no context on event.locals; export handle = bs.handle from hooks.server.ts");
+		if (!locals.bsb) throw new TypeError("better-supabase: no context on event.locals; export handle = bsb.handle from hooks.server.ts");
 		return locals;
 	};
 	const refuse = (error, request) => {
@@ -66,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, locals);
+			const caller = await requireCaller(locals.bsb.auth, requireOptions, locals.tenant, server.authorizer, locals);
 			if ("kind" in caller) return refuse(caller, event.request);
 			return {
 				...locals,
@@ -77,10 +77,10 @@ function createSvelteKit(betterSupabase, options = {}) {
 			return async (event) => {
 				const locals = localsFrom(event);
 				const input = await actionInput(event.request);
-				const result = await runAction(locals.bs.auth, actionOptions, input, locals.tenant, (parsed, caller) => fn(parsed, {
+				const result = await runAction(locals.bsb.auth, actionOptions, input, locals.tenant, (parsed, caller) => fn(parsed, {
 					...locals,
 					...caller
-				}, event), options.authorizer, locals);
+				}, event), server.authorizer, locals);
 				if (!result.ok && options.kit) return options.kit.fail(result.error.status, result);
 				return result;
 			};
@@ -97,7 +97,7 @@ function createSvelteKit(betterSupabase, options = {}) {
 			return { message: expose && error instanceof Error ? error.message : "Internal Error" };
 		},
 		depends(load, ...tables) {
-			for (const table of tables) load.depends(`bs:${table}`);
+			for (const table of tables) load.depends(`bsb:${table}`);
 		}
 	});
 }

package/dist/table-schema-BlF6k62Q.d.ts

@@ -0,0 +1,81 @@
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/core/table-json-schema.d.ts
+/** Validator for one scalar, independent of the target library. */
+type ScalarKind = {
+  readonly kind: "uuid";
+} | {
+  readonly kind: "string";
+} | {
+  readonly kind: "integer";
+} | {
+  readonly kind: "number";
+} | {
+  readonly kind: "boolean";
+} | {
+  readonly kind: "datetime";
+} | {
+  readonly kind: "date";
+} | {
+  readonly kind: "instant";
+} | {
+  readonly kind: "plainDate";
+} | {
+  readonly kind: "plainDateTime";
+} | {
+  readonly kind: "bigint";
+} | {
+  readonly kind: "json";
+} | {
+  readonly kind: "enum";
+  readonly values: readonly string[];
+} | {
+  readonly kind: "unknown";
+};
+interface FieldOptions {
+  readonly nullable?: boolean;
+  /** The key may be left out. A present key never accepts `undefined`. */
+  readonly optional?: boolean;
+  readonly array?: boolean;
+  /**
+   * Filled by a block extension (`updatedAtExtension()`,
+   * `createdByExtension()`, `trashExtension()`).
+   */
+  readonly readOnly?: boolean;
+  readonly description?: string;
+  readonly examples?: readonly unknown[];
+  readonly minimum?: number;
+  readonly exclusiveMinimum?: number;
+  readonly maximum?: number;
+  readonly exclusiveMaximum?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  /** Validates a typed jsonb column; its JSON Schema is used when it has one. */
+  readonly schema?: StandardSchemaV1;
+}
+/**
+ * One column of a table schema. `custom` is a jsonb column with a TypeScript
+ * type from the config and no schema: any value except `undefined` passes.
+ */
+type FieldSpec = (ScalarKind | {
+  readonly kind: "custom";
+}) & FieldOptions;
+interface TableSchemaSpec {
+  readonly title?: string;
+  readonly description?: string;
+  readonly fields: Readonly<Record<string, FieldSpec>>;
+}
+//#endregion
+//#region src/core/table-schema.d.ts
+/** A Standard Schema that also converts to JSON Schema (Standard JSON Schema). */
+interface TableSchema<T> {
+  readonly "~standard": StandardSchemaV1.Props<T, T> & StandardJSONSchemaV1.Props<T, T>;
+}
+/**
+ * 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.
+ */
+declare function tableSchema<T>(spec: TableSchemaSpec): TableSchema<T>;
+//#endregion
+export { ScalarKind as a, FieldSpec as i, TableSchema as n, TableSchemaSpec as o, tableSchema as r, StandardJSONSchemaV1 as t };