better-supabase 0.14.0 → 0.15.0

package/dist/block-hooks-BymdcD0V.js

@@ -1,130 +0,0 @@
-import { n as dbError, o as isDbError } from "./errors-03ysrOt4.js";
-import { r as err, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { t as consoleLogger } from "./logger-glM28NVN.js";
-import { o as blockCall } from "./block-helpers-CiKtrb6g.js";
-//#region src/core/block-hooks.ts
-const isPlainObject = (value) => {
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-};
-/**
-* A copy of plain objects and arrays; class instances (Temporal values) are
-* immutable and stay shared.
-*/
-function copyOf(value) {
-	if (Array.isArray(value)) return value.map(copyOf);
-	if (typeof value === "object" && value !== null && isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyOf(entry)]));
-	return value;
-}
-/**
-* A new client with the same methods: a spread for object literals, a child
-* object otherwise.
-*/
-function cloneClient(client) {
-	if (isPlainObject(client)) return { ...client };
-	return Object.create(client);
-}
-/** The client's method named `name`, or undefined when it has none. */
-function methodOf(client, name) {
-	const value = client[name];
-	if (typeof value !== "function") return;
-	return value;
-}
-/**
-* Runs `hooks` around a block client's methods. Use it to add a rule the block
-* doesn't know (refuse `invite` above a seat limit), rewrite arguments (fill a
-* default), or observe results (metrics, an audit line). Methods without hooks
-* are unchanged.
-*
-* ```ts
-* const orgs = withBlockHooks(createOrganizations(options), {
-*   invite: {
-*     before: ([input]) =>
-*       input.role === "owner"
-*         ? dbError("forbidden", "Owners are added by support")
-*         : undefined,
-*   },
-* });
-* ```
-*/
-function withBlockHooks(client, hooks, options = {}) {
-	if (hooks === void 0) return client;
-	const block = options.block ?? "block";
-	const logger = options.logger ?? consoleLogger;
-	const wrapped = cloneClient(client);
-	for (const [method, hook] of Object.entries(hooks)) {
-		if (hook === void 0) continue;
-		const original = methodOf(client, method);
-		if (original === void 0) throw new TypeError(`better-supabase: ${block} has no method "${method}" to hook`);
-		const { before, after } = hook;
-		const info = {
-			block,
-			method
-		};
-		wrapped[method] = (...args) => AsyncResult.from(async () => {
-			let current = args;
-			if (before) {
-				const outcome = await before(current, info);
-				if (isDbError(outcome)) return err(outcome);
-				if (Array.isArray(outcome)) current = outcome;
-			}
-			const result = await original.apply(client, current);
-			if (after) try {
-				await after(copyOf(result), current, info);
-			} catch (cause) {
-				logger.error(`${block}.${method} after hook threw`, { cause });
-			}
-			return result;
-		});
-	}
-	return wrapped;
-}
-/**
-* Adds methods to a block client. The builder gets the base client, so a new
-* method can compose existing ones, and `call` for SQL functions the app adds
-* to the block's schema. Redefining a base method throws: wrap it with
-* `withBlockHooks` instead.
-*
-* ```ts
-* const orgs = extendBlock(
-*   createOrganizations(options),
-*   (base, { call }) => ({
-*     archive: (id: string) =>
-*       call("archive_organization", { id }, () => undefined),
-*   }),
-*   { transport: options.transport },
-* );
-* ```
-*/
-function extendBlock(client, build, options = {}) {
-	const { transport } = options;
-	const additions = build(client, { call: transport ? blockCall(transport, options.schema ?? "better_supabase", options.mappers ?? []) : () => AsyncResult.err(dbError("unsupported", "extendBlock needs the transport option to call SQL functions")) });
-	const taken = Object.keys(additions).filter((key) => key in client);
-	if (taken.length > 0) throw new TypeError(`better-supabase: extendBlock can't redefine ${taken.map((key) => `"${key}"`).join(", ")}; wrap a base method with withBlockHooks instead`);
-	return Object.assign(cloneClient(client), additions);
-}
-/** Fills in `apiVersion: 1`. */
-function defineTransportMiddleware(middleware) {
-	return {
-		...middleware,
-		apiVersion: 1
-	};
-}
-/**
-* A transport that runs `middleware` around `transport`, the first one
-* outermost. Throws when a middleware targets an API other than 1.
-*/
-function wrapTransport(transport, ...middleware) {
-	for (const entry of middleware) {
-		const version = entry.apiVersion;
-		if (version !== 1) throw new TypeError(`better-supabase: transport middleware "${entry.name}" targets API ${String(version)}; this better-supabase supports 1`);
-	}
-	const run = middleware.reduceRight((next, entry) => (request) => entry.call(request, next), (request) => transport.call(request.schema, request.fn, request.args));
-	return { call: (schema, fn, args) => run({
-		schema,
-		fn,
-		args
-	}) };
-}
-//#endregion
-export { wrapTransport as i, extendBlock as n, withBlockHooks as r, defineTransportMiddleware as t };

package/dist/block-hooks-CmjPKqQ_.d.ts

@@ -1,117 +0,0 @@
-import { T as ErrorMapper, b as DbError, f as Result, t as AsyncResult } from "./result-C6jDfedy.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { t as BlockCall } from "./block-helpers-BaugZlJV.js";
-import { t as BlockTransport } from "./block-transport-d53POsem.js";
-//#region src/core/block-hooks.d.ts
-/** A block method: anything that returns an `AsyncResult`. */
-type BlockMethod = (...args: never[]) => AsyncResult<unknown>;
-/** The names of a block client's methods that return an `AsyncResult`. */
-type BlockMethodName<C> = { [K in keyof C]: C[K] extends BlockMethod ? K : never; }[keyof C] & string;
-type ArgsOf<F> = F extends ((...args: infer A) => AsyncResult<unknown>) ? A : never;
-type DataOf<F> = F extends ((...args: never[]) => AsyncResult<infer T>) ? T : never;
-/** Which call a hook runs for. */
-interface BlockHookInfo {
-  /** The block, as `createBlocks` names it, or the name `withBlockHooks` got. */
-  readonly block: string;
-  readonly method: string;
-}
-/**
- * Hooks for one block method. `before` runs first: return nothing to keep the
- * arguments, a new argument list to replace them, or a `DbError` to refuse the
- * call, which then returns that error without reaching the database. `after`
- * observes a copy of the result and can't change it; when it throws, the logger
- * gets the error and the caller still gets the result.
- */
-interface BlockMethodHooks<A extends readonly unknown[], T> {
-  readonly before?: (args: A, info: BlockHookInfo) => Readonly<A> | DbError | void | Promise<Readonly<A> | DbError | void>;
-  readonly after?: (result: Result<T>, args: A, info: BlockHookInfo) => void | Promise<void>;
-}
-/** Hooks keyed by the block client's method names. */
-type BlockHooks<C> = { readonly [K in BlockMethodName<C>]?: BlockMethodHooks<ArgsOf<C[K]>, DataOf<C[K]>>; };
-interface WithBlockHooksOptions {
-  /** The block's name in `BlockHookInfo` and log messages. Default `block`. */
-  readonly block?: string;
-  /** Receives the errors `after` hooks throw. Default: `console`. */
-  readonly logger?: Logger;
-}
-/**
- * Runs `hooks` around a block client's methods. Use it to add a rule the block
- * doesn't know (refuse `invite` above a seat limit), rewrite arguments (fill a
- * default), or observe results (metrics, an audit line). Methods without hooks
- * are unchanged.
- *
- * ```ts
- * const orgs = withBlockHooks(createOrganizations(options), {
- *   invite: {
- *     before: ([input]) =>
- *       input.role === "owner"
- *         ? dbError("forbidden", "Owners are added by support")
- *         : undefined,
- *   },
- * });
- * ```
- */
-declare function withBlockHooks<C extends object>(client: C, hooks: BlockHooks<C> | undefined, options?: WithBlockHooksOptions): C;
-/** What `extendBlock` hands the builder besides the base client. */
-interface ExtendBlockTools {
-  /**
-   * Calls a SQL function in the block's schema over its transport and maps a
-   * rejection to a `DbError`, as the block's own methods do. Needs the
-   * `transport` option.
-   */
-  readonly call: BlockCall;
-}
-interface ExtendBlockOptions {
-  /** The transport `call` uses: the one the block was created with. */
-  readonly transport?: BlockTransport;
-  /** The schema `call` targets. Default `better_supabase`. */
-  readonly schema?: string;
-  /** Error mappers `call` runs before the built-in ones. */
-  readonly mappers?: readonly ErrorMapper[];
-}
-/**
- * Adds methods to a block client. The builder gets the base client, so a new
- * method can compose existing ones, and `call` for SQL functions the app adds
- * to the block's schema. Redefining a base method throws: wrap it with
- * `withBlockHooks` instead.
- *
- * ```ts
- * const orgs = extendBlock(
- *   createOrganizations(options),
- *   (base, { call }) => ({
- *     archive: (id: string) =>
- *       call("archive_organization", { id }, () => undefined),
- *   }),
- *   { transport: options.transport },
- * );
- * ```
- */
-declare function extendBlock<C extends object, X extends object>(client: C, build: (base: C, tools: ExtendBlockTools) => X, options?: ExtendBlockOptions): C & X;
-/** One transport call, as middleware sees it. */
-interface BlockTransportRequest {
-  readonly schema: string;
-  readonly fn: string;
-  readonly args: Readonly<Record<string, unknown>>;
-}
-/**
- * Runs around every call a transport makes: tracing, a statement timeout, an
- * extra argument every function takes. Pass a changed request to `next` to
- * rewrite it. Reject with the error `next` rejected with so the block still
- * maps it to a `DbError`.
- */
-interface BlockTransportMiddleware {
-  readonly apiVersion: 1;
-  readonly name: string;
-  call(request: BlockTransportRequest, next: (request: BlockTransportRequest) => Promise<unknown>): Promise<unknown>;
-}
-/** Fills in `apiVersion: 1`. */
-declare function defineTransportMiddleware(middleware: Omit<BlockTransportMiddleware, "apiVersion"> & {
-  readonly apiVersion?: 1;
-}): BlockTransportMiddleware;
-/**
- * A transport that runs `middleware` around `transport`, the first one
- * outermost. Throws when a middleware targets an API other than 1.
- */
-declare function wrapTransport(transport: BlockTransport, ...middleware: readonly BlockTransportMiddleware[]): BlockTransport;
-//#endregion
-export { BlockTransportMiddleware as a, ExtendBlockTools as c, extendBlock as d, withBlockHooks as f, BlockMethodName as i, WithBlockHooksOptions as l, BlockHooks as n, BlockTransportRequest as o, wrapTransport as p, BlockMethodHooks as r, ExtendBlockOptions as s, BlockHookInfo as t, defineTransportMiddleware as u };

package/dist/block-method-Bvsao626.js

@@ -1,21 +0,0 @@
-//#region src/blocks/block-method.ts
-/**
-* Calls `method` with `input` as one value: an array is spread when the method
-* takes more than one argument, as `BlockInputOf` describes.
-*/
-function callWithInput(client, method, input) {
-	const call = methodOf(client, method);
-	if (call.length > 1 && Array.isArray(input)) return call(...input);
-	return call(input);
-}
-/**
-* The bound method `method` of a block client. Throws a `TypeError` when the
-* client has no such method.
-*/
-function methodOf(client, method) {
-	const value = client[method];
-	if (typeof value !== "function") throw new TypeError(`better-supabase: the block client has no ${method}`);
-	return value.bind(client);
-}
-//#endregion
-export { methodOf as n, callWithInput as t };

package/dist/block-method-hsPAGFi5.d.ts

@@ -1,19 +0,0 @@
-import { f as Result } from "./result-C6jDfedy.js";
-//#region src/blocks/block-method.d.ts
-type AnyMethod = (...args: never[]) => PromiseLike<Result<unknown>>;
-/** The method names of a block client. */
-type BlockMethodName<C> = { readonly [K in keyof C]: C[K] extends AnyMethod ? K : never; }[keyof C] & string;
-/** The arguments of a block client method. */
-type BlockArgsOf<C, K extends BlockMethodName<C>> = C[K] extends ((...args: infer A) => PromiseLike<Result<unknown>>) ? A : never;
-/**
- * What one call of a block method takes as a single value: its argument, or the
- * tuple of its arguments when it has more than one.
- */
-type BlockInputOf<C, K extends BlockMethodName<C>> = BlockArgsOf<C, K>["length"] extends 0 | 1 ? BlockArgsOf<C, K>[0] : BlockArgsOf<C, K>;
-/** The data a block client method's `Result` carries. */
-type BlockDataOf<C, K extends BlockMethodName<C>> = C[K] extends ((...args: never[]) => PromiseLike<infer R>) ? R extends {
-  readonly ok: true;
-  readonly data: infer D;
-} ? D : never : never;
-//#endregion
-export { BlockMethodName as i, BlockDataOf as n, BlockInputOf as r, BlockArgsOf as t };

package/dist/block-names-Dbv_2wmE.js

@@ -1,66 +0,0 @@
-import { i as entityNames, o as tenantNames, r as composeNames } from "./entity-naming-DLDhHTbK.js";
-import { t as defineTransportMiddleware } from "./block-hooks-BymdcD0V.js";
-//#region src/core/block-names.ts
-const TENANT_COLUMNS = ["organization_id", "active_organization_id"];
-const OPAQUE_KEYS = /* @__PURE__ */ new Set(["fields", "metadata"]);
-const KEY_VALUES = /* @__PURE__ */ new Set(["field"]);
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-function renameEntry(key, value, rename) {
-	if (OPAQUE_KEYS.has(key)) return value;
-	if (KEY_VALUES.has(key) && typeof value === "string") return rename(value);
-	return renameKeys(value, rename);
-}
-/**
-* `value` with every key of every plain object in it passed through `rename`,
-* and the column a `field` names, leaving the values under `fields` and
-* `metadata` alone.
-*/
-function renameKeys(value, rename) {
-	if (Array.isArray(value)) return value.map((each) => renameKeys(each, rename));
-	if (!isPlainObject(value)) return value;
-	return Object.fromEntries(Object.entries(value).map(([key, each]) => [rename(key), renameEntry(key, each, rename)]));
-}
-/** The arguments with the keys nested inside them renamed; parameter names stay. */
-function renameArgs(args, entities) {
-	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, renameEntry(key, value, (each) => entities.rename(each))]));
-}
-/**
-* Transport middleware that calls each block function by the name the SQL wrote
-* it under and translates the payload keys: `create_organization` becomes
-* `create_workspace` with `tenant: "workspace"`, `list_work_items` becomes
-* `list_tasks` with `work_item` renamed to `task`, then `functions` renames
-* single functions. Keys inside the arguments (`projectId`) go out renamed, and
-* the keys of the result come back by their default names, so the block's
-* client reads what it always has. Wrap a block's transport with it when the
-* config sets `blocks.<name>.entities` or `blocks.<name>.functions`;
-* `defineBlocks` does it from `blocks.generated.ts`.
-*/
-function blockNames(naming) {
-	const tenant = tenantNames(naming.tenant);
-	const entities = entityNames(naming.entities);
-	const names = composeNames(tenant, entities);
-	const functions = naming.functions ?? {};
-	const rename = (fn) => {
-		const renamed = names.rename(fn);
-		return functions[fn] ?? functions[renamed] ?? renamed;
-	};
-	const columns = new Map(TENANT_COLUMNS.map((column) => [tenant.rename(column), column]));
-	const restore = (key) => columns.get(key) ?? entities.reverse(key);
-	return defineTransportMiddleware({
-		name: "block-names",
-		call: async (request, next) => {
-			const result = await next({
-				...request,
-				fn: rename(request.fn),
-				...entities.renamed ? { args: renameArgs(request.args, entities) } : {}
-			});
-			return names.renamed ? renameKeys(result, restore) : result;
-		}
-	});
-}
-//#endregion
-export { renameKeys as n, blockNames as t };

package/dist/block-subjects-Dzq5Xn_0.js

@@ -1,55 +0,0 @@
-import { a as ok, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { I as textOf } from "./block-helpers-CiKtrb6g.js";
-//#region src/core/block-subjects.ts
-/** A row's subject columns as a `SubjectRef`. */
-function subjectRefOf(type, id) {
-	return {
-		type: textOf(type),
-		id: textOf(id)
-	};
-}
-/** A row's subject columns as a `SubjectRef`, or `undefined` when unset. */
-function optionalSubjectRefOf(type, id) {
-	return typeof type === "string" && type !== "" && (typeof id === "string" || typeof id === "number") ? {
-		type,
-		id: String(id)
-	} : void 0;
-}
-/**
-* The ids of `subjects` grouped by type, in first-seen order and without
-* repeats, for functions that take one subject type and many ids.
-*/
-function subjectIdsByType(subjects) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const subject of subjects) {
-		const ids = grouped.get(subject.type) ?? [];
-		if (!ids.includes(subject.id)) ids.push(subject.id);
-		grouped.set(subject.type, ids);
-	}
-	return grouped;
-}
-/** The map key of a subject in a batch result: `type:id`. */
-function subjectKey(subject) {
-	return `${subject.type}:${subject.id}`;
-}
-/**
-* One call per subject type over `subjects`, the results merged into one record
-* keyed by `subjectKey` (`type:id`). The first error wins.
-*/
-function bySubjectType(subjects, call) {
-	return AsyncResult.from(async () => {
-		const merged = {};
-		const groups = [...subjectIdsByType(subjects)];
-		const results = await Promise.all(groups.map(async ([type, ids]) => [type, await call(type, ids)]));
-		for (const [type, result] of results) {
-			if (!result.ok) return result;
-			for (const [id, value] of Object.entries(result.data)) merged[subjectKey({
-				type,
-				id
-			})] = value;
-		}
-		return ok(merged);
-	});
-}
-//#endregion
-export { subjectRefOf as i, optionalSubjectRefOf as n, subjectKey as r, bySubjectType as t };

package/dist/block-subjects-FHwLlIHU.d.ts

@@ -1,6 +0,0 @@
-import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
-//#region src/core/block-subjects.d.ts
-/** The map key of a subject in a batch result: `type:id`. */
-declare function subjectKey(subject: SubjectRef): string;
-//#endregion
-export { subjectKey as t };

package/dist/block-tenant-C1sNV8_4.js

@@ -1,14 +0,0 @@
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { t as AsyncResult } from "./result-B3m7xtRY.js";
-import { t as currentTenant } from "./tenant-source-bqWpSr86.js";
-//#region src/core/block-tenant.ts
-/**
-* Reads the tenant for one call: `invalid_request` with the hint
-* `TENANT_REQUIRED` when there is none.
-*/
-function requireTenant(source) {
-	const tenant = currentTenant(source);
-	return tenant === void 0 ? AsyncResult.err(dbError("invalid_request", "No tenant is active: pass `tenant` to the block, or call it from a request that has one", { hint: "TENANT_REQUIRED" })) : AsyncResult.ok(tenant);
-}
-//#endregion
-export { requireTenant as t };

package/dist/block-transport-d53POsem.d.ts

@@ -1,69 +0,0 @@
-import { r as Executor } from "./executor-CPyrQdjh.js";
-import { n as SqlClient } from "./executor-CsTaO3AT.js";
-//#region src/core/block-transport.d.ts
-/**
- * Calls a block function as the current user and resolves with its result.
- * Rejects with the raw database error (a `pg` error or a PostgREST error
- * object), which the block maps to a `DbError`.
- */
-interface BlockTransport {
-  call(schema: string, fn: string, args: Readonly<Record<string, unknown>>): Promise<unknown>;
-}
-/**
- * Calls the functions over Postgres, as the user `client` runs as:
- * `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
- */
-declare function sqlTransport(client: SqlClient): BlockTransport;
-interface RpcResponse {
-  readonly data: unknown;
-  readonly error: unknown;
-}
-/**
- * The part of a supabase-js client `rpcTransport` uses. The parameters are
- * `never` so a typed `SupabaseClient<Database>` fits too: its `schema` and
- * `rpc` only take the names its `Database` declares, which never include the
- * block functions of a schema the types leave out.
- */
-interface RpcClient {
-  schema(name: never): {
-    rpc(fn: never, args: never): PromiseLike<RpcResponse>;
-  };
-}
-/** Options for `rpcTransport`. */
-interface RpcTransportOptions {
-  /**
-   * The exposed schema that holds the block's entry points, such as `api` from
-   * `blocks.<module>.api`. Every call goes there instead of the module schema,
-   * which stays out of `[api] schemas` (doctor BS312).
-   */
-  readonly schema?: string;
-}
-/**
- * Calls the functions over the Data API with the user's session. Pass `schema`
- * with the API schema that `blocks.<module>.api` writes wrappers into; without
- * it the calls go to the module schema, which then has to be exposed.
- */
-declare function rpcTransport(client: RpcClient, options?: RpcTransportOptions): BlockTransport;
-/** Options for `dbTransport`. */
-interface DbTransportOptions {
-  /**
-   * The schema every call goes to instead of the module schema, such as the API
-   * schema from `blocks.<module>.api`. Over PostgREST it has to be exposed;
-   * over Postgres any schema the caller may use works.
-   */
-  readonly schema?: string;
-}
-/** The part of a `Db` that `dbTransport` uses. */
-interface DbTransportSource {
-  readonly $executor: Executor;
-}
-/**
- * Calls the functions through a `Db`'s executor, so a block runs wherever the
- * `Db` does: over PostgREST for `ctx.db` in a normal request, and over direct
- * Postgres as the target in a support session or for an API key. Rejects with
- * the raw database error, like the other transports, so the block's error
- * mappers see the same codes and hints.
- */
-declare function dbTransport(db: DbTransportSource, options?: DbTransportOptions): BlockTransport;
-//#endregion
-export { dbTransport as a, RpcClient as i, DbTransportOptions as n, rpcTransport as o, DbTransportSource as r, sqlTransport as s, BlockTransport as t };

package/dist/blocks/access/index.d.ts

@@ -1,9 +0,0 @@
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
-import { c as BlockOf } from "../../define-block-COpcS6aT.js";
-import { B as PermissionFlags, H as can, U as permissionFlags, V as PermissionSet, W as permissionMatches } from "../../index-DbXWcrOI.js";
-import { a as PermissionsSnapshot, c as Access, d as createAccess, i as PermissionsControllerOptions, l as AccessCallOptions, n as PermissionsActions, o as batchPermissions, r as PermissionsController, s as createPermissionsController, t as PermissionSource, u as AccessOptions } from "../../client-LngH55pZ.js";
-//#region src/blocks/access/manifest.d.ts
-/** The `access` block's manifest (ADR 0029). */
-export declare const accessBlock: BlockOf<"access", typeof createAccess>;
-//#endregion
-export { type Access, type AccessCallOptions, type AccessOptions, type BlockTransport, type PermissionFlags, type PermissionSet, type PermissionSource, type PermissionsActions, type PermissionsController, type PermissionsControllerOptions, type PermissionsSnapshot, batchPermissions, can, createAccess, createPermissionsController, dbTransport, permissionFlags, permissionMatches, rpcTransport, sqlTransport };

package/dist/blocks/access/index.js

@@ -1,18 +0,0 @@
-import { t as accessSqlOptions } from "../../options-a-28mlYT.js";
-import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CiKtrb6g.js";
-import { n as permissionFlags, r as permissionMatches, t as can } from "../../permissions-BetA_Fo_.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { t as createAccess } from "../../access-z7NwWtqx.js";
-import { n as createPermissionsController, t as batchPermissions } from "../../client-BtRx0-kn.js";
-//#region src/blocks/access/manifest.ts
-/** The `access` block's manifest (ADR 0029). */
-const accessBlock = defineBlock({
-	name: "access",
-	sql: ["access"],
-	options: { access: accessSqlOptions },
-	create: createAccess,
-	category: "identity",
-	recipes: ["can"]
-});
-//#endregion
-export { accessBlock, batchPermissions, can, createAccess, createPermissionsController, dbTransport, permissionFlags, permissionMatches, rpcTransport, sqlTransport };

package/dist/blocks/access/react/index.d.ts

@@ -1,52 +0,0 @@
-import { V as PermissionSet } from "../../../index-DbXWcrOI.js";
-import { a as PermissionsSnapshot, n as PermissionsActions } from "../../../client-LngH55pZ.js";
-import { ReactNode } from "react";
-//#region src/blocks/access/react/index.d.ts
-export interface UsePermissionsOptions {
-  /** The organization to check in. Default the client's tenant. */
-  readonly tenant?: string;
-}
-export interface PermissionsState<K extends string = string> extends PermissionsSnapshot, PermissionsActions {
-  /** Whether the caller holds `key`; false while loading. */
-  readonly can: (key: K) => boolean;
-}
-/**
- * Which of `keys` the caller holds in the client's tenant, through the access
- * contract. The hooks rendered in the same tick share one `my_permissions`
- * call. UX only: RLS checks every key again.
- *
- * ```tsx
- * const { can } = usePermissions([permissions.invoices.write]);
- * ```
- */
-export declare function usePermissions<const K extends string>(keys: readonly K[], options?: UsePermissionsOptions): PermissionsState<K>;
-/**
- * Whether the caller holds `key` in the client's tenant: `undefined` while it
- * loads, then true or false.
- *
- * ```tsx
- * const canEdit = usePermission(permissions.invoices.write);
- * ```
- */
-export declare function usePermission<const K extends string>(key: K, options?: UsePermissionsOptions): boolean | undefined;
-export interface CanProps<K extends string = string> {
-  /** The permission key, such as `permissions.invoices.write`. */
-  readonly permission: K;
-  /** The organization to check in. Default the client's tenant. */
-  readonly tenant?: string;
-  /** Shown while loading and when the caller lacks the key. Default nothing. */
-  readonly fallback?: ReactNode;
-  readonly children?: ReactNode;
-}
-/**
- * Renders `children` when the caller holds `permission`, else `fallback`.
- *
- * ```tsx
- * <Can permission={permissions.invoices.write}>
- *   <Button>Edit</Button>
- * </Can>;
- * ```
- */
-export declare function Can<const K extends string>(props: CanProps<K>): ReactNode;
-//#endregion
-export type { PermissionSet };

package/dist/blocks/access/react/index.js

@@ -1,73 +0,0 @@
-"use client";
-import { t as useController } from "../../../react-controller-CKSdtJ10.js";
-import { n as useBlockTenant, t as useBlockEnv } from "../../../react-env-CfA3EdBH.js";
-import { t as can } from "../../../permissions-BetA_Fo_.js";
-import { t as createAccess } from "../../../access-z7NwWtqx.js";
-import { n as createPermissionsController, t as batchPermissions } from "../../../client-BtRx0-kn.js";
-import { t as envBlockOptions } from "../../../block-env-options-2e6IQrSw.js";
-//#region src/blocks/access/react/index.ts
-const sources = /* @__PURE__ */ new WeakMap();
-/** One batched access client per supabase-js client, shared by its hooks. */
-function sourceOf(env) {
-	let source = sources.get(env.supabase);
-	if (source === void 0) {
-		source = batchPermissions(createAccess(envBlockOptions(env, "access")));
-		sources.set(env.supabase, source);
-	}
-	return source;
-}
-/**
-* Which of `keys` the caller holds in the client's tenant, through the access
-* contract. The hooks rendered in the same tick share one `my_permissions`
-* call. UX only: RLS checks every key again.
-*
-* ```tsx
-* const { can } = usePermissions([permissions.invoices.write]);
-* ```
-*/
-function usePermissions(keys, options = {}) {
-	const env = useBlockEnv();
-	const current = useBlockTenant(env);
-	const tenant = options.tenant ?? current;
-	const key = [...new Set(keys)].toSorted().join("\n");
-	const { view } = useController(() => createPermissionsController({
-		client: sourceOf(env),
-		auth: env.auth,
-		keys: key === "" ? [] : key.split("\n"),
-		tenant
-	}), [
-		env,
-		tenant,
-		key
-	]);
-	return {
-		...view,
-		can: (wanted) => can(view.permissions, wanted)
-	};
-}
-/**
-* Whether the caller holds `key` in the client's tenant: `undefined` while it
-* loads, then true or false.
-*
-* ```tsx
-* const canEdit = usePermission(permissions.invoices.write);
-* ```
-*/
-function usePermission(key, options = {}) {
-	const { permissions, can: holds } = usePermissions([key], options);
-	return permissions === void 0 ? void 0 : holds(key);
-}
-/**
-* Renders `children` when the caller holds `permission`, else `fallback`.
-*
-* ```tsx
-* <Can permission={permissions.invoices.write}>
-*   <Button>Edit</Button>
-* </Can>;
-* ```
-*/
-function Can(props) {
-	return usePermission(props.permission, props.tenant === void 0 ? {} : { tenant: props.tenant }) === true ? props.children : props.fallback ?? null;
-}
-//#endregion
-export { Can, usePermission, usePermissions };