better-supabase 0.12.0 → 0.13.0

package/dist/comments-Ceqo9bwE.js

@@ -0,0 +1,230 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { t as AsyncResult } from "./result-DIT_qp4G.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as stripTypePrefix } from "./cloud-event-XsM53POL.js";
+import { C as optionalText, D as recordOf, F as stringsOf, I as textOf, R as toInstant, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall, w as pageOf } from "./block-helpers-DwE32_gT.js";
+import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
+import { n as blockFields } from "./block-fields-Cwd4c8m-.js";
+import { n as defineListQuery } from "./list-query-CuS1w2Af.js";
+//#region src/blocks/comments/comments.ts
+const ACTIVITY_SOURCES = [
+	"event",
+	"audit",
+	"delivery",
+	"run"
+];
+function sourceOf(value) {
+	return ACTIVITY_SOURCES.find((source) => source === value) ?? "event";
+}
+const MENTION = /@\[[^\]\n]{1,100}\]\(([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\)/gi;
+/**
+* The user ids mentioned in a body written as `@[Ada](<user id>)`, the markup
+* mention inputs produce, in order and without repeats.
+*/
+function mentionsIn(body) {
+	return [...new Set([...body.matchAll(MENTION)].flatMap((match) => match[1] ? [match[1].toLowerCase()] : []))];
+}
+function commentOf(value) {
+	const row = recordOf(value, "comments");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		subjectType: textOf(row["subject_type"]),
+		subjectId: textOf(row["subject_id"]),
+		authorId: optionalText(row["author_id"]),
+		body: textOf(row["body"] ?? ""),
+		document: row["document"] ?? null,
+		mentions: stringsOf(row["mentions"]),
+		parentId: optionalText(row["parent_id"]),
+		createdAt: toInstant(textOf(row["created_at"])),
+		editedAt: optionalInstant(row["edited_at"]),
+		deletedAt: optionalInstant(row["deleted_at"]),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function activityOf(value) {
+	const row = recordOf(value, "activity_entries");
+	return {
+		id: textOf(row["id"]),
+		source: sourceOf(row["source"]),
+		organizationId: textOf(row["organization_id"]),
+		type: textOf(row["type"]),
+		actorId: optionalText(row["actor_id"]),
+		subjectType: optionalText(row["subject_type"]),
+		subjectId: optionalText(row["subject_id"]),
+		summary: optionalText(row["summary"]),
+		data: isRecord(row["data"]) ? row["data"] : {},
+		occurredAt: toInstant(textOf(row["occurred_at"]))
+	};
+}
+/** Comments over the `comments` module's functions, as the caller. */
+function createComments(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "comment fields");
+	const mentionsOf = (body, rich) => options.mentionsOf ? options.mentionsOf({
+		body,
+		document: rich
+	}) : mentionsIn(body);
+	return withBlockHooks({
+		create: (comment) => fields.args(comment.fields).andThen((checked) => call("create_comment", {
+			tenant: comment.organizationId,
+			subject_type: comment.subjectType,
+			subject_id: comment.subjectId,
+			body: comment.body,
+			mentions: comment.mentions ?? mentionsOf(comment.body, comment.document),
+			parent: comment.parentId,
+			document: comment.document,
+			fields: checked
+		}, commentOf).andThen(fields.row)),
+		edit: (id, edit) => fields.args(edit.fields).andThen((checked) => call("edit_comment", {
+			id,
+			body: edit.body,
+			mentions: edit.mentions ?? mentionsOf(edit.body, edit.document),
+			document: edit.document ?? void 0,
+			...edit.document === null ? { clear_document: true } : {},
+			fields: checked
+		}, (value) => value).andThen((value) => value === null || value === void 0 ? AsyncResult.err(dbError("not_found", "No comment you can edit has this id", { hint: "COMMENT_NOT_FOUND" })) : fields.row(commentOf(value)))),
+		remove: (id) => call("delete_comment", { id }, (value) => value === true),
+		list: (organizationId, subjectType, subjectId, list = {}) => call("list_comments", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			after: instantArg(pageOf(list).cursor),
+			max_rows: list.limit,
+			skip: list.offset,
+			after_id: list.cursorId
+		}, (value) => recordsOf(value, "list_comments").map(commentOf)).andThen(fields.rows),
+		counts: (organizationId, subjectType, subjectIds) => call("comment_counts", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_ids: [...subjectIds]
+		}, (value) => {
+			const found = isRecord(value) ? value : {};
+			return Object.fromEntries(subjectIds.map((id) => [id, Number(found[id] ?? 0)]));
+		}),
+		copy: (organizationId, from, to) => call("copy_comments", {
+			tenant: organizationId,
+			from_type: from.type,
+			from_id: from.id,
+			to_type: to.type,
+			to_id: to.id
+		}, (value) => Number(value ?? 0)),
+		history: (organizationId, subject, history = {}) => call("list_activity", {
+			tenant: organizationId,
+			subject_type: subject?.type,
+			subject_id: subject?.id,
+			before: instantArg(pageOf(history).cursor),
+			max_rows: history.limit,
+			sources: history.sources ? [...history.sources] : void 0
+		}, (value) => recordsOf(value, "list_activity").map(activityOf))
+	}, options.hooks, {
+		block: "comments",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+const matches = (patterns, type) => patterns.some((pattern) => pattern.endsWith(".*") ? type.startsWith(pattern.slice(0, -1)) : pattern === type);
+const firstText = (data, keys) => {
+	for (const key of keys) {
+		const value = optionalText(data[key]);
+		if (value !== void 0) return value;
+	}
+};
+/** `comments/<id>` as `{ type: "comment", id }`, the shape block subjects use. */
+function subjectOf(subject) {
+	const slash = subject?.indexOf("/") ?? -1;
+	if (subject === void 0 || slash < 1) return;
+	const plural = subject.slice(0, slash);
+	return {
+		type: plural.endsWith("s") ? plural.slice(0, -1) : plural,
+		id: subject.slice(slash + 1)
+	};
+}
+/**
+* An outbox sink that writes events into the activity feed:
+* `outbox.relay('activity', activitySink({ transport }))`. Events without a
+* tenant (`partitionkey`) are skipped, and a replayed event writes nothing.
+*/
+function activitySink(options) {
+	const call = blockCall(options.transport, options.schema);
+	return { async send(events) {
+		const entries = [];
+		for (const event of events) {
+			const tenant = optionalText(event["partitionkey"]);
+			if (tenant === void 0) continue;
+			const type = stripTypePrefix(event.type, options.typePrefix);
+			if (options.types && !matches(options.types, type)) continue;
+			const described = options.describe ? options.describe(event, type) : {};
+			if (described === null) continue;
+			const data = isRecord(event.data) ? event.data : {};
+			const subject = subjectOf(event.subject);
+			entries.push({
+				event_id: event.id,
+				organization_id: tenant,
+				type,
+				actor_id: described?.actorId ?? firstText(data, [
+					"actorId",
+					"authorId",
+					"userId"
+				]),
+				subject_type: described?.subjectType ?? optionalText(data["subjectType"]) ?? subject?.type,
+				subject_id: described?.subjectId ?? optionalText(data["subjectId"]) ?? subject?.id,
+				summary: described?.summary,
+				data: described?.data ?? data,
+				occurred_at: event.time
+			});
+		}
+		if (entries.length > 0) await call("record_activity", { batch: { entries } }, () => void 0).orThrow();
+	} };
+}
+const FACETS = [
+	[
+		"type",
+		"type",
+		"type"
+	],
+	[
+		"actor",
+		"actor_id",
+		"actorId"
+	],
+	[
+		"subjectType",
+		"subject_type",
+		"subjectType"
+	],
+	[
+		"subjectId",
+		"subject_id",
+		"subjectId"
+	]
+];
+/**
+* A cursor-paged list over `activity_entries` (generate types for the
+* `better_supabase` schema to get it in your models), newest first, filtered by
+* type, actor and subject. Members with `activity.read` see their tenants'
+* entries, less those on a registered subject that `can_subject` doesn't let
+* them read (with the `subjects` module). It reads the table, so it lists no
+* audit entries; `history()` does.
+*/
+function activityListQuery(betterSupabase, table, options = {}) {
+	const meta = betterSupabase.meta.tables[table];
+	if (!meta) throw new TypeError(`activityListQuery: unknown table "${table}"`);
+	const camel = meta.columns["occurredAt"] !== void 0;
+	const facets = Object.fromEntries(FACETS.map(([key, snake, camelName]) => [key, camel ? camelName : snake]).filter(([, column]) => meta.columns[column] !== void 0));
+	const occurredAt = camel ? "occurredAt" : "occurred_at";
+	const config = {
+		facets,
+		sorts: {
+			newest: [{ [occurredAt]: "desc" }, { id: "desc" }],
+			oldest: [{ [occurredAt]: "asc" }, { id: "asc" }]
+		},
+		defaultSort: "newest",
+		pagination: "cursor",
+		...options.pageSize === void 0 ? {} : { pageSize: options.pageSize },
+		...options.maxPageSize === void 0 ? {} : { maxPageSize: options.maxPageSize }
+	};
+	return defineListQuery(betterSupabase, table, config);
+}
+//#endregion
+export { mentionsIn as i, activitySink as n, createComments as r, activityListQuery as t };

package/dist/commerce/index.d.ts

@@ -1,13 +1,13 @@
-import { f as Result } from "../result-BREt7qOh.js";
-import { n as StripeSource } from "../stripe-NVcNOhHy.js";
-import { S as toDecimal, _ as negateMoney, a as allocateMoney, b as subtractMoney, c as formatMoney, d as isRate, f as minorUnits, g as multiplyMoney, h as moneyToJson, i as addMoney, l as isCurrency, m as moneyFromJson, n as Money, o as applyRate, p as money, r as MoneyJson, s as compareMoney, t as CurrencyMismatchError, u as isMoney, v as parseMoney, x as sumMoney, y as roundHalfEven } from "../money-DFpWzQvk.js";
-import { C as PaymentProvider, D as RefundStatus, E as RefundInput, O as invalidPaymentAmount, S as PaymentEventType, T as Refund, _ as taxProviderOf, a as TaxCart, b as PaymentCallOptions, c as TaxLine, d as TaxRates, f as TaxReverseInput, g as reversalOf, h as invalidTaxCart, i as TaxCallOptions, k as paymentProviderOf, l as TaxProvider, m as fixedRates, n as SHIPPING_LINE, o as TaxCartLine, p as TaxTransaction, r as TaxAddress, s as TaxCommitInput, t as FixedRatesOptions, u as TaxQuote, v as CreatePaymentInput, w as PaymentStatus, x as PaymentEvent, y as Payment } from "../tax-DMWDUzKt.js";
+import { f as Result } from "../result-mijqfoJN.js";
+import { n as StripeSource } from "../stripe-BSEwKCni.js";
+import { S as toDecimal, _ as negateMoney, a as allocateMoney, b as subtractMoney, c as formatMoney, d as isRate, f as minorUnits, g as multiplyMoney, h as moneyToJson, i as addMoney, l as isCurrency, m as moneyFromJson, n as Money, o as applyRate, p as money, r as MoneyJson, s as compareMoney, t as CurrencyMismatchError, u as isMoney, v as parseMoney, x as sumMoney, y as roundHalfEven } from "../money-BNRdJQzA.js";
+import { C as PaymentProvider, D as RefundStatus, E as RefundInput, O as invalidPaymentAmount, S as PaymentEventType, T as Refund, _ as taxProviderOf, a as TaxCart, b as PaymentCallOptions, c as TaxLine, d as TaxRates, f as TaxReverseInput, g as reversalOf, h as invalidTaxCart, i as TaxCallOptions, k as paymentProviderOf, l as TaxProvider, m as fixedRates, n as SHIPPING_LINE, o as TaxCartLine, p as TaxTransaction, r as TaxAddress, s as TaxCommitInput, t as FixedRatesOptions, u as TaxQuote, v as CreatePaymentInput, w as PaymentStatus, x as PaymentEvent, y as Payment } from "../tax-BHSCb5Rw.js";
 //#region src/commerce/iso4217.d.ts
 /**
- * Minor units per ISO 4217 currency code, from ISO 4217 List One as
- * published on the date in `SPEC_PINS.iso4217`. Codes without minor units
- * (precious metals, SDR and testing codes) are left out: they are not money
- * a price or a payment can carry.
+ * Minor units per ISO 4217 currency code, from ISO 4217 List One as published
+ * on the date in `SPEC_PINS.iso4217`. Codes without minor units (precious
+ * metals, SDR and testing codes) are left out: they are not money a price or a
+ * payment can carry.
  */
 export declare const ISO_4217_MINOR_UNITS: Readonly<Record<string, number>>;
 //#endregion
@@ -44,8 +44,8 @@ interface StripeRefund {
   } | null;
 }
 /**
- * The part of the Stripe SDK `stripePayments` calls, typed structurally so
- * the block never imports `stripe`.
+ * The part of the Stripe SDK `stripePayments` calls, typed structurally so the
+ * block never imports `stripe`.
  */
 interface StripePaymentsClient {
   readonly paymentIntents: {
@@ -64,8 +64,9 @@ interface StripePaymentsClient {
 }
 interface StripePaymentsOptions {
   /**
-   * A client, a factory such as `stripeFromKey()` from `better-supabase/stripe`,
-   * or `{ secretKey }` to create one from `stripe` in plain Node.
+   * A client, a factory such as `stripeFromKey()` from
+   * `better-supabase/stripe`, or `{ secretKey }` to create one from `stripe` in
+   * plain Node.
    */
   readonly stripe: StripeSource<StripePaymentsClient>;
   /** The endpoint's `whsec_` secret; several while it rotates. */
@@ -73,33 +74,36 @@ interface StripePaymentsOptions {
   /** Defaults to `stripe`. */
   readonly name?: string;
   /**
-   * Extra PaymentIntent parameters, such as `{ automatic_payment_methods:
-   * { enabled: true } }` (the default) or `payment_method_types`.
+   * Extra PaymentIntent parameters, such as `{ automatic_payment_methods: {
+   * enabled: true } }` (the default) or `payment_method_types`.
    */
   readonly paymentIntent?: Params$1;
   /** Seconds a webhook timestamp may be off. Defaults to 300. */
   readonly tolerance?: number;
 }
 /**
- * The payment events in a verified Stripe event, such as one the webhook
- * inbox stored with `stripeInboxVerify`. Event types the contract doesn't
- * cover give none. Needs `Temporal`.
+ * The payment events in a verified Stripe event, such as one the webhook inbox
+ * stored with `stripeInboxVerify`. Event types the contract doesn't cover give
+ * none. Needs `Temporal`.
  */
 export declare function stripePaymentEvents(event: unknown): readonly PaymentEvent[];
 /**
- * A `PaymentProvider` on Stripe PaymentIntents. `stripe` is an optional
- * peer, loaded on first use when `stripe` is `{ secretKey }`; webhooks are
- * verified with WebCrypto, without it.
+ * A `PaymentProvider` on Stripe PaymentIntents. `stripe` is an optional peer,
+ * loaded on first use when `stripe` is `{ secretKey }`; webhooks are verified
+ * with WebCrypto, without it.
  */
 export declare function stripePayments(options: StripePaymentsOptions): PaymentProvider;
 //#endregion
 //#region src/commerce/stripe-shared.d.ts
-/** The `amount` Stripe takes for `value`, or the error when Stripe can't charge it exactly. */
+/**
+ * The `amount` Stripe takes for `value`, or the error when Stripe can't charge
+ * it exactly.
+ */
 export declare function toStripeAmount(value: Money): Result<number>;
 /**
- * `Money` from a Stripe `amount` and its lowercase currency, or the error
- * when the amount has a fraction of the currency's minor unit (an ISK or UGX
- * amount that isn't a multiple of 100).
+ * `Money` from a Stripe `amount` and its lowercase currency, or the error when
+ * the amount has a fraction of the currency's minor unit (an ISK or UGX amount
+ * that isn't a multiple of 100).
  */
 export declare function fromStripeAmount(amount: number, currency: string): Result<Money>;
 //#endregion
@@ -167,8 +171,8 @@ interface StripeTaxTransactionLine {
   readonly reference: string;
 }
 /**
- * The part of the Stripe SDK `stripeTax` calls, typed structurally so the
- * block never imports `stripe`.
+ * The part of the Stripe SDK `stripeTax` calls, typed structurally so the block
+ * never imports `stripe`.
  */
 interface StripeTaxClient {
   readonly tax: {
@@ -188,23 +192,24 @@ interface StripeTaxClient {
 }
 interface StripeTaxOptions {
   /**
-   * A client, a factory such as `stripeFromKey()` from `better-supabase/stripe`,
-   * or `{ secretKey }` to create one from `stripe` in plain Node.
+   * A client, a factory such as `stripeFromKey()` from
+   * `better-supabase/stripe`, or `{ secretKey }` to create one from `stripe` in
+   * plain Node.
    */
   readonly stripe: StripeSource<StripeTaxClient>;
   /** Defaults to `stripe-tax`. */
   readonly name?: string;
   /**
-   * Stripe tax codes by `taxCategory`, such as `{ ebook: "txcd_10302000" }`.
-   * A category that starts with `txcd_` is passed as is; others without an
-   * entry use the account's default tax code.
+   * Stripe tax codes by `taxCategory`, such as `{ ebook: "txcd_10302000" }`. A
+   * category that starts with `txcd_` is passed as is; others without an entry
+   * use the account's default tax code.
    */
   readonly taxCodes?: Readonly<Record<string, string>>;
 }
 /**
  * A `TaxProvider` on Stripe Tax: `quote` creates a calculation, `commit` a
- * transaction from it, and `reverse` a full or partial reversal. `stripe`
- * is an optional peer, loaded on first use when `stripe` is `{ secretKey }`.
+ * transaction from it, and `reverse` a full or partial reversal. `stripe` is an
+ * optional peer, loaded on first use when `stripe` is `{ secretKey }`.
  */
 export declare function stripeTax(options: StripeTaxOptions): TaxProvider;
 //#endregion

package/dist/commerce/index.js

@@ -1,17 +1,18 @@
-import { n as dbError } from "../errors-BV1SKTVs.js";
-import { c as optionalTemporal } from "../temporal-CB5Fpo5d.js";
-import { t as temporal } from "../temporal-required-nfZ87U-0.js";
-import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../result-DIeYscA3.js";
-import { t as ISO_4217_MINOR_UNITS } from "../iso4217-A8ev-CNW.js";
-import { s as verifyStripeWebhook } from "../verify-DnU-uWU2.js";
-import { _ as roundHalfEven, a as compareMoney, b as toDecimal, c as isMoney, d as money, f as moneyFromJson, g as parseMoney, h as negateMoney, i as applyRate, l as isRate, m as multiplyMoney, n as addMoney, o as formatMoney, p as moneyToJson, r as allocateMoney, s as isCurrency, t as CurrencyMismatchError, u as minorUnits, v as subtractMoney, y as sumMoney } from "../money-95Rff2vT.js";
-import { n as paymentProviderOf, t as invalidPaymentAmount } from "../payments-CzjCdIcz.js";
-import { t as lazyStripe } from "../stripe-XZrSmDTf.js";
-import { a as taxProviderOf, i as reversalOf, n as fixedRates, r as invalidTaxCart, t as SHIPPING_LINE } from "../tax-wm9g2mD2.js";
+import { n as dbError } from "../errors-D7u24ZJH.js";
+import { c as optionalTemporal } from "../temporal-DLZlWbOi.js";
+import { t as temporal } from "../temporal-required-Dt4mcPsi.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../result-DIT_qp4G.js";
+import { t as ISO_4217_MINOR_UNITS } from "../iso4217-B-durg_y.js";
+import { s as verifyStripeWebhook } from "../verify-BCmBaHlN.js";
+import { _ as roundHalfEven, a as compareMoney, b as toDecimal, c as isMoney, d as money, f as moneyFromJson, g as parseMoney, h as negateMoney, i as applyRate, l as isRate, m as multiplyMoney, n as addMoney, o as formatMoney, p as moneyToJson, r as allocateMoney, s as isCurrency, t as CurrencyMismatchError, u as minorUnits, v as subtractMoney, y as sumMoney } from "../money-BZl985O-.js";
+import { n as paymentProviderOf, t as invalidPaymentAmount } from "../payments-6uuergov.js";
+import { t as lazyStripe } from "../stripe-BJUfp5jM.js";
+import { a as taxProviderOf, i as reversalOf, n as fixedRates, r as invalidTaxCart, t as SHIPPING_LINE } from "../tax-keSd-q_1.js";
 //#region src/commerce/stripe-shared.ts
 /**
-* Stripe's decimals where they differ from ISO 4217 (docs.stripe.com/currencies):
-* ISK and UGX keep two for backward compatibility, MGA has none.
+* Stripe's decimals where they differ from ISO 4217
+* (docs.stripe.com/currencies): ISK and UGX keep two for backward
+* compatibility, MGA has none.
 */
 const STRIPE_DECIMALS = {
 	ISK: 2,
@@ -27,7 +28,10 @@ const STRIPE_ROUND_TO_TEN = /* @__PURE__ */ new Set([
 	"TND"
 ]);
 const stripeDecimals = (currency) => STRIPE_DECIMALS[currency] ?? minorUnits(currency);
-/** The `amount` Stripe takes for `value`, or the error when Stripe can't charge it exactly. */
+/**
+* The `amount` Stripe takes for `value`, or the error when Stripe can't charge
+* it exactly.
+*/
 function toStripeAmount(value) {
 	const shift = stripeDecimals(value.currency) - minorUnits(value.currency);
 	const scale = 10n ** BigInt(Math.abs(shift));
@@ -38,9 +42,9 @@ function toStripeAmount(value) {
 	return ok(Number(amount));
 }
 /**
-* `Money` from a Stripe `amount` and its lowercase currency, or the error
-* when the amount has a fraction of the currency's minor unit (an ISK or UGX
-* amount that isn't a multiple of 100).
+* `Money` from a Stripe `amount` and its lowercase currency, or the error when
+* the amount has a fraction of the currency's minor unit (an ISK or UGX amount
+* that isn't a multiple of 100).
 */
 function fromStripeAmount(amount, currency) {
 	const code = currency.toUpperCase();
@@ -52,8 +56,8 @@ function fromStripeAmount(amount, currency) {
 	return ok(money(shift < 0 ? value * scale : value / scale, code));
 }
 /**
-* A thrown Stripe error as a `DbError`: a declined card is `raised` with
-* the hint `PAYMENT_DECLINED`, a missing object `not_found`, a bad request
+* A thrown Stripe error as a `DbError`: a declined card is `raised` with the
+* hint `PAYMENT_DECLINED`, a missing object `not_found`, a bad request
 * `invalid_input`, and the rest by HTTP status.
 */
 function stripeError(cause) {
@@ -75,7 +79,10 @@ function stripeError(cause) {
 	if (type === "StripeConnectionError") return dbError("network", message, extra);
 	return toDbError(cause);
 }
-/** Runs Stripe calls as a result, mapping a thrown Stripe error with `stripeError`. */
+/**
+* Runs Stripe calls as a result, mapping a thrown Stripe error with
+* `stripeError`.
+*/
 function stripeResult(work) {
 	return AsyncResult.from(async () => {
 		try {
@@ -152,9 +159,9 @@ function refundOf(refund, paymentId) {
 const objectOf = (value) => typeof value === "object" && value !== null ? { ...value } : {};
 const text = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
 /**
-* The payment events in a verified Stripe event, such as one the webhook
-* inbox stored with `stripeInboxVerify`. Event types the contract doesn't
-* cover give none. Needs `Temporal`.
+* The payment events in a verified Stripe event, such as one the webhook inbox
+* stored with `stripeInboxVerify`. Event types the contract doesn't cover give
+* none. Needs `Temporal`.
 */
 function stripePaymentEvents(event) {
 	const envelope = objectOf(event);
@@ -205,9 +212,9 @@ function stripePaymentEvents(event) {
 	return [];
 }
 /**
-* A `PaymentProvider` on Stripe PaymentIntents. `stripe` is an optional
-* peer, loaded on first use when `stripe` is `{ secretKey }`; webhooks are
-* verified with WebCrypto, without it.
+* A `PaymentProvider` on Stripe PaymentIntents. `stripe` is an optional peer,
+* loaded on first use when `stripe` is `{ secretKey }`; webhooks are verified
+* with WebCrypto, without it.
 */
 function stripePayments(options) {
 	const name = options.name ?? "stripe";
@@ -290,7 +297,10 @@ async function allPages(first, next) {
 	}
 }
 const PERCENT = /^(\d+)(?:\.(\d+))?$/;
-/** The summed `percentage_decimal`s of a breakdown as a fraction string: "21.0" gives "0.21". */
+/**
+* The summed `percentage_decimal`s of a breakdown as a fraction string: "21.0"
+* gives "0.21".
+*/
 function rateOf(breakdown) {
 	let digits = 0;
 	const parts = [];
@@ -346,8 +356,8 @@ const addressOf = (address) => ({
 });
 /**
 * A `TaxProvider` on Stripe Tax: `quote` creates a calculation, `commit` a
-* transaction from it, and `reverse` a full or partial reversal. `stripe`
-* is an optional peer, loaded on first use when `stripe` is `{ secretKey }`.
+* transaction from it, and `reverse` a full or partial reversal. `stripe` is an
+* optional peer, loaded on first use when `stripe` is `{ secretKey }`.
 */
 function stripeTax(options) {
 	const name = options.name ?? "stripe-tax";

package/dist/compiler-DCotQWcs.d.ts

@@ -0,0 +1,14 @@
+import { v as Operation } from "./executor-C29668fO.js";
+import { a as PostgrestPlan } from "./postgrest-DGjrW4sK.js";
+//#region src/core/compiler.d.ts
+/**
+ * Turns an IR operation into something a backend runs. An `Executor` for a new
+ * backend usually pairs with a `Compiler` for it.
+ */
+interface Compiler<TTarget> {
+  readonly target: string;
+  compile(op: Operation): TTarget;
+}
+declare const postgrestCompiler: Compiler<PostgrestPlan>;
+//#endregion
+export { postgrestCompiler as n, Compiler as t };

package/dist/compose-VBQL7zIO.js

@@ -0,0 +1,53 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { t as AsyncResult } from "./result-DIT_qp4G.js";
+import { n as credentialRefInTenant, t as credentialProviderOf } from "./provider-BhIkKBOh.js";
+//#region src/credentials/compose.ts
+const NO_CAPABILITIES = {
+	userSubjects: false,
+	authorization: false,
+	revoke: false,
+	inbound: false
+};
+const unsupported = (provider, what) => dbError("unsupported", `The credential provider "${provider}" ${what}`, { hint: "CREDENTIAL_UNSUPPORTED" });
+/**
+* One provider over several: each call goes to the provider whose `name` is the
+* ref's `provider`. A ref no provider handles fails with `invalid_input`
+* (`CREDENTIAL_PROVIDER_UNKNOWN`), and an optional method the chosen provider
+* lacks with `unsupported`.
+*/
+function credentialRouter(providers, options = {}) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const provider of providers) {
+		if (byName.has(provider.name)) throw new TypeError(`credentialRouter got two providers named "${provider.name}"`);
+		byName.set(provider.name, credentialProviderOf(provider));
+	}
+	const unknown = (ref) => dbError("invalid_input", `No credential provider named "${ref.provider}" is configured`, { hint: "CREDENTIAL_PROVIDER_UNKNOWN" });
+	const route = (ref, then) => {
+		const provider = byName.get(ref.provider);
+		return provider === void 0 ? AsyncResult.err(unknown(ref)) : then(provider);
+	};
+	return {
+		apiVersion: 1,
+		name: options.name ?? "router",
+		getToken: (ref, tokenOptions) => route(ref, (provider) => provider.getToken(ref, tokenOptions)),
+		capabilities: (ref) => byName.get(ref.provider)?.capabilities(ref) ?? NO_CAPABILITIES,
+		startAuthorization: (ref, startOptions) => route(ref, (provider) => provider.startAuthorization === void 0 ? AsyncResult.err(unsupported(provider.name, "doesn't authorize accounts")) : provider.startAuthorization(ref, startOptions)),
+		completeAuthorization: (ref, completeOptions) => route(ref, (provider) => provider.completeAuthorization === void 0 ? AsyncResult.err(unsupported(provider.name, "doesn't authorize accounts")) : provider.completeAuthorization(ref, completeOptions)),
+		revoke: (ref, revokeOptions) => route(ref, (provider) => provider.revoke(ref, revokeOptions)),
+		verifyInbound: (request, ref) => route(ref, (provider) => provider.verifyInbound === void 0 ? AsyncResult.err(unsupported(provider.name, "doesn't verify inbound requests")) : provider.verifyInbound(request, ref)),
+		set: (ref, value, setOptions) => route(ref, (provider) => provider.set === void 0 ? AsyncResult.err(unsupported(provider.name, "can't store secrets")) : provider.set(ref, value, setOptions))
+	};
+}
+/**
+* Revokes the credential a ref names when a provider is configured and can
+* revoke it. Resolves `false` without a provider, for a provider without
+* revocation, or for a ref outside `options.tenant`.
+*/
+function revokeIfConfigured(provider, ref, options) {
+	if (provider === void 0) return AsyncResult.ok(false);
+	if ("tenant" in options && !credentialRefInTenant(ref, options.tenant)) return AsyncResult.ok(false);
+	if (!provider.capabilities(ref).revoke) return AsyncResult.ok(false);
+	return provider.revoke(ref, { subject: options.subject });
+}
+//#endregion
+export { revokeIfConfigured as n, credentialRouter as t };

package/dist/composite-BgBzdYP-.d.ts

@@ -0,0 +1,82 @@
+import { a as AnyModels, i as AnyFunctions } from "./types-DmshMaXz.js";
+import { r as AuthState } from "./resolve-D57oDWNr.js";
+import { o as Db, t as BetterSupabase } from "./define-D0LSXmUP.js";
+import { K as ReplicaState, a as ServerContext, c as ServerOptions, n as BetterServer, v as ActiveSupport } from "./server-types-D_cQ6OxZ.js";
+import { n as SessionEntryConfig } from "./session-DNRYXIOU.js";
+import { r as GuardOptions } from "./respond-QW-f1yio.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Entry, SingleKeyEntry } from "@supabase/middleware";
+import { AuthMode, JWTClaims, UserClaims } from "@supabase/server";
+//#region src/server/entries/guard.d.ts
+interface GuardEntryConfig extends GuardOptions {
+  /**
+   * Include error messages in problem responses. Defaults to `NODE_ENV ===
+   * 'development'`.
+   */
+  readonly expose?: boolean;
+}
+/**
+ * Entry that answers callers `allow`, `aal` or `scopes` refuse with a 401 or
+ * 403 Problem Details response, before the handler runs. It contributes
+ * `ctx.guard`, the options the caller passed.
+ */
+declare function withGuard<C, P>(config?: GuardEntryConfig): SingleKeyEntry<"guard", {
+  readonly auth: AuthState<C, P>;
+}, GuardOptions>;
+//#endregion
+//#region src/server/composite.d.ts
+/** What `withBetterSupabase` takes besides the definition or server. */
+interface BetterSupabaseConfig extends SessionEntryConfig, GuardEntryConfig {}
+/** The keys `withBetterSupabase` puts on `ctx`. */
+interface BetterSupabaseContributions<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> {
+  /**
+   * The full request context: `auth`, `supabase`, `stats()`, `apply()` and the
+   * rest.
+   */
+  bs: ServerContext<M, F, E, C, P, B>;
+  /** The verified token's payload, or `null`; the key `withSupabase` uses. */
+  jwtClaims: (JWTClaims & C) | null;
+  userClaims: UserClaims | null;
+  authMode: AuthMode;
+  /** Repositories over PostgREST as the caller. */
+  db: Db<M, F, E, SupabaseClient, B>;
+  /**
+   * Repositories over direct Postgres as the caller, when Postgres is
+   * configured or upstream.
+   */
+  sql: Db<M, F, E, undefined, B> | undefined;
+  tenant: string | undefined;
+  support: ActiveSupport | undefined;
+  replica: ReplicaState | undefined;
+}
+/**
+ * The entry `withBetterSupabase` returns, for `pipeline` and the framework
+ * bridges.
+ */
+type BetterSupabaseEntry<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = Entry<BetterSupabaseContributions<M, F, E, C, P, B>>;
+/**
+ * The whole better-supabase server as one `@supabase/middleware` entry: it
+ * verifies the caller (bearer token or session cookie), refuses callers the
+ * guard rejects with Problem Details, and contributes `ctx.db`, `ctx.sql`,
+ * `ctx.bs` and the `withSupabase` keys (`jwtClaims`, `userClaims`, `authMode`),
+ * so `withPostgresClient` and `withOpenFeature` compose after it. Refreshed
+ * cookies and `bs-primary-until` go out on the response.
+ *
+ * ```ts
+ * export default {
+ *   fetch: pipeline(
+ *     [withBetterSupabase(betterSupabase)],
+ *     async (req, ctx) =>
+ *       Response.json(await ctx.db.notes.findMany().orThrow()),
+ *   ),
+ * };
+ * ```
+ *
+ * Pass a server from `createServer` to share its clients and JWKS cache with
+ * the rest of the app; pass the definition to build one with `config`'s server
+ * options.
+ */
+declare function withBetterSupabase<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P, B>, config?: BetterSupabaseConfig & ServerOptions): BetterSupabaseEntry<M, F, E, C, P, B>;
+declare function withBetterSupabase<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(server: BetterServer<M, F, E, C, P, B>, config?: BetterSupabaseConfig): BetterSupabaseEntry<M, F, E, C, P, B>;
+//#endregion
+export { GuardEntryConfig as a, withBetterSupabase as i, BetterSupabaseContributions as n, withGuard as o, BetterSupabaseEntry as r, BetterSupabaseConfig as t };