better-supabase 0.12.0 → 0.14.0

package/dist/overlay/index.d.ts

@@ -1,6 +1,9 @@
-import { c as SpecDiagnostic } from "../format-CNwSjXUU.js";
+import { c as SpecDiagnostic } from "../format-AYHceC2m.js";
 //#region src/overlay/types.d.ts
-/** The Overlay versions `applyOverlay` reads. Patch versions are ignored (Overlay § 4.1). */
+/**
+ * The Overlay versions `applyOverlay` reads. Patch versions are ignored
+ * (Overlay § 4.1).
+ */
 type OverlayVersion = "1.0.0" | "1.1.0" | "1.2.0";
 /** Specification extensions: fields that start with `x-` (Overlay 1.2 § 4.7). */
 type Extensions = {
@@ -17,13 +20,16 @@ type OverlayInfo = {
 /** Fields every action kind shares. */
 interface ActionFields {
   readonly description?: string;
-  /** Merged into objects, concatenated or appended to arrays, or replaces primitives. */
+  /**
+   * Merged into objects, concatenated or appended to arrays, or replaces
+   * primitives.
+   */
   readonly update?: unknown;
   /** When `true`, every selected node is removed. Wins over `update` and `copy`. */
   readonly remove?: boolean;
   /**
-   * Accept a target that selects nothing. Without it, `applyOverlay`
-   * reports `overlay-no-match` as an error.
+   * Accept a target that selects nothing. Without it, `applyOverlay` reports
+   * `overlay-no-match` as an error.
    */
   readonly "x-better-supabase-allow-empty"?: boolean;
 }
@@ -78,10 +84,10 @@ type Overlay12 = OverlayBase & {
 /** An Overlay document of any supported version. */
 type Overlay = Overlay10 | Overlay11 | Overlay12;
 /**
- * The JSONPath engine `applyOverlay` runs targets with. `paths` returns the
- * RFC 9535 normalized paths (`$['paths']['/a'][0]`) of the selected nodes
- * and throws for an invalid query. `loadJsonPath()` returns the
- * `jsonpath-rfc9535` engine; any RFC 9535 implementation fits.
+ * The JSONPath engine `applyOverlay` runs targets with. `paths` returns the RFC
+ * 9535 normalized paths (`$['paths']['/a'][0]`) of the selected nodes and
+ * throws for an invalid query. `loadJsonPath()` returns the `jsonpath-rfc9535`
+ * engine; any RFC 9535 implementation fits.
  */
 interface JsonPathEngine {
   paths(document: unknown, expression: string): readonly string[];
@@ -94,49 +100,56 @@ interface ApplyOverlayOptions {
 interface OverlayResult<T> {
   /** A new document; the input is never changed. */
   readonly document: T;
-  /** Errors, warnings and notes, in action order. Callers decide what fails a build. */
+  /**
+   * Errors, warnings and notes, in action order. Callers decide what fails a
+   * build.
+   */
   readonly diagnostics: readonly SpecDiagnostic[];
 }
 //#endregion
 //#region src/overlay/apply.d.ts
 /**
- * Applies an Overlay 1.0, 1.1 or 1.2 document to `document` and returns a
- * new document. The input is cloned once with `structuredClone` and never
- * changed; each target runs once through `options.jsonpath`.
+ * Applies an Overlay 1.0, 1.1 or 1.2 document to `document` and returns a new
+ * document. The input is cloned once with `structuredClone` and never changed;
+ * each target runs once through `options.jsonpath`.
  *
- * Actions run in order, each on the result of the previous one (Overlay
- * § 4.5.1.1). `update` merges objects, concatenates or appends to arrays and
+ * Actions run in order, each on the result of the previous one (Overlay §
+ * 4.5.1.1). `update` merges objects, concatenates or appends to arrays and
  * replaces primitives; `remove` deletes the selected nodes; `copy` (1.1 and
  * later) uses the value of the single node its query selects. Reusable action
- * references (1.2) are expanded, with a warning when the overlay declares
- * 1.0 or 1.1.
+ * references (1.2) are expanded, with a warning when the overlay declares 1.0
+ * or 1.1.
  *
  * Problems never throw: they are diagnostics, and the failing action is
- * skipped. A target that selects nothing reports `overlay-no-match` as an
- * error unless the action sets `x-better-supabase-allow-empty: true` or the
- * options set `allowEmpty`. The other codes are `overlay-invalid-target`,
- * `overlay-invalid-action`, `overlay-mixed-targets`,
- * `overlay-merge-conflict`, `overlay-copy-source`, `overlay-ref-unresolved`,
- * `overlay-version-feature`, `overlay-version-unsupported` and
- * `overlay-empty-action`.
+ * skipped. A target that selects nothing reports `overlay-no-match` as an error
+ * unless the action sets `x-better-supabase-allow-empty: true` or the options
+ * set `allowEmpty`. The other codes are `overlay-invalid-target`,
+ * `overlay-invalid-action`, `overlay-mixed-targets`, `overlay-merge-conflict`,
+ * `overlay-copy-source`, `overlay-ref-unresolved`, `overlay-version-feature`,
+ * `overlay-version-unsupported` and `overlay-empty-action`.
  *
- * The result keeps the input's type; an overlay that changes the shape
- * needs the caller to narrow it.
+ * The result keeps the input's type; an overlay that changes the shape needs
+ * the caller to narrow it.
  *
  * @example
- * const jsonpath = await loadJsonPath();
- * const { document, diagnostics } = applyOverlay(openapi, overlay, { jsonpath });
+ *   const jsonpath = await loadJsonPath();
+ *   const { document, diagnostics } = applyOverlay(openapi, overlay, {
+ *     jsonpath,
+ *   });
  */
 export declare function applyOverlay<T>(document: T, overlay: Overlay, options: ApplyOverlayOptions): OverlayResult<T>;
 /**
  * Applies overlays in order, each to the result of the previous one, with a
- * single clone of the input. Diagnostic pointers start with the overlay's
- * index (`/1/actions/0`).
+ * single clone of the input. Diagnostic pointers start with the overlay's index
+ * (`/1/actions/0`).
  */
 export declare function applyOverlays<T>(document: T, overlays: readonly Overlay[], options: ApplyOverlayOptions): OverlayResult<T>;
 //#endregion
 //#region src/overlay/define.d.ts
-/** What `defineOverlay` accepts: an Overlay document whose `overlay` field is optional. */
+/**
+ * What `defineOverlay` accepts: an Overlay document whose `overlay` field is
+ * optional.
+ */
 type OverlayInput = {
   readonly overlay?: OverlayVersion;
   readonly info: OverlayInfo;
@@ -165,22 +178,25 @@ type DefinedOverlay<I extends OverlayInput> = I extends {
 /**
  * Defines an Overlay document with checks a schema cannot make. `overlay`
  * defaults to `1.1.0`, or to `1.2.0` when the input uses a 1.2 feature
- * (`components`, `$self` or a reusable action reference), and the return
- * type follows it.
+ * (`components`, `$self` or a reusable action reference), and the return type
+ * follows it.
  *
- * Throws a `TypeError` when there are no actions, when a feature needs a
- * newer version than the one set (`copy` needs 1.1, reusable actions and
- * `$self` need 1.2), when a reference names a missing reusable action, or
- * when `extends` or `$self` contains a fragment.
+ * Throws a `TypeError` when there are no actions, when a feature needs a newer
+ * version than the one set (`copy` needs 1.1, reusable actions and `$self` need
+ * 1.2), when a reference names a missing reusable action, or when `extends` or
+ * `$self` contains a fragment.
  *
  * @example
- * const overlay = defineOverlay({
- *   info: { title: "Public API", version: "1.0.0" },
- *   actions: [
- *     { target: "$.paths['/customers'].get", update: { summary: "List customers" } },
- *     { target: "$.paths[?@['x-internal'] == true]", remove: true },
- *   ],
- * });
+ *   const overlay = defineOverlay({
+ *     info: { title: "Public API", version: "1.0.0" },
+ *     actions: [
+ *       {
+ *         target: "$.paths['/customers'].get",
+ *         update: { summary: "List customers" },
+ *       },
+ *       { target: "$.paths[?@['x-internal'] == true]", remove: true },
+ *     ],
+ *   });
  */
 export declare function defineOverlay<const I extends OverlayInput>(input: I): DefinedOverlay<I>;
 /**
@@ -206,15 +222,15 @@ type OverlayOf<V extends OverlayVersion> = V extends "1.0.0" ? Overlay10 : V ext
 /**
  * Writes the Overlay that turns `base` into `enriched`, so other tools can
  * reproduce what hooks and transforms changed. Targets use stable keys
- * (`$.paths['/customers'].get`); array indexes appear only inside arrays of
- * the same length.
+ * (`$.paths['/customers'].get`); array indexes appear only inside arrays of the
+ * same length.
  *
  * A deleted key becomes a `remove` action; added keys become one `update` on
- * their parent; a changed primitive becomes an `update` on it (1.1 and
- * later) or a `remove` and re-add (1.0). An array that only grew gets its new
- * items appended; any other array change replaces the array. Applying the
- * result to `base` gives a document equal to `enriched`, though replaced
- * keys move to the end of their object.
+ * their parent; a changed primitive becomes an `update` on it (1.1 and later)
+ * or a `remove` and re-add (1.0). An array that only grew gets its new items
+ * appended; any other array change replaces the array. Applying the result to
+ * `base` gives a document equal to `enriched`, though replaced keys move to the
+ * end of their object.
  *
  * Throws a `TypeError` when the roots are not both objects, or when the two
  * documents are equal (an overlay needs at least one action).
@@ -223,10 +239,10 @@ export declare function overlayFromDiff<V extends OverlayVersion = "1.1.0">(base
 //#endregion
 //#region src/overlay/load.d.ts
 /**
- * Loads the optional `jsonpath-rfc9535` peer, an RFC 9535 implementation
- * that passes the JSONPath Compliance Test Suite, for `applyOverlay`.
- * Rejects with an install message when the package is missing. The engine
- * is loaded once per module; `importer` replaces the import in tests.
+ * Loads the optional `jsonpath-rfc9535` peer, an RFC 9535 implementation that
+ * passes the JSONPath Compliance Test Suite, for `applyOverlay`. Rejects with
+ * an install message when the package is missing. The engine is loaded once per
+ * module; `importer` replaces the import in tests.
  */
 export declare function loadJsonPath(importer?: () => Promise<unknown>): Promise<JsonPathEngine>;
 //#endregion

package/dist/overlay/index.js

@@ -1,4 +1,4 @@
-import { n as memoized, t as importOptionalPeer } from "../optional-peer-Dx8TaYXw.js";
+import { n as memoized, t as importOptionalPeer } from "../optional-peer-C1NbBRJm.js";
 //#region src/overlay/path.ts
 const ESCAPES = {
 	b: "\b",
@@ -11,8 +11,8 @@ const ESCAPES = {
 	"/": "/"
 };
 /**
-* Parses an RFC 9535 normalized path (§ 2.7), such as `$['paths'][0]`, into
-* its segments. Throws for anything else, because the engine promised one.
+* Parses an RFC 9535 normalized path (§ 2.7), such as `$['paths'][0]`, into its
+* segments. Throws for anything else, because the engine promised one.
 */
 function parseNormalizedPath(path) {
 	if (!path.startsWith("$")) throw new TypeError(`Not a normalized path: ${path}`);
@@ -20,15 +20,15 @@ function parseNormalizedPath(path) {
 	let i = 1;
 	while (i < path.length) {
 		if (path[i] !== "[") throw new TypeError(`Not a normalized path: ${path}`);
-		i++;
+		i += 1;
 		if (path[i] === "'") {
-			i++;
+			i += 1;
 			let name = "";
 			while (i < path.length && path[i] !== "'") {
 				const char = path[i] ?? "";
 				if (char !== "\\") {
 					name += char;
-					i++;
+					i += 1;
 					continue;
 				}
 				const next = path[i + 1] ?? "";
@@ -101,7 +101,10 @@ function readMinor(version) {
 	const minor = Number(match[1]);
 	return minor === 0 || minor === 1 || minor === 2 ? minor : void 0;
 }
-/** An Action Object needs a string target; the other fields are read defensively. */
+/**
+* An Action Object needs a string target; the other fields are read
+* defensively.
+*/
 const isAction = (entry) => typeof entry["target"] === "string";
 function report(reporter, severity, code, message, pointer) {
 	reporter.diagnostics.push({
@@ -156,7 +159,10 @@ function resolve(document, segments) {
 }
 const escapeToken = (segment) => `/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`;
 const toPointer = (segments) => segments.map(escapeToken).join("");
-/** Merges `source` into `target` recursively (§ 4.5.4.1) and collects the conflicting pointers. */
+/**
+* Merges `source` into `target` recursively (§ 4.5.4.1) and collects the
+* conflicting pointers.
+*/
 function mergeInto(target, source, at, conflicts) {
 	for (const [key, value] of Object.entries(source)) {
 		if (!Object.hasOwn(target, key)) {
@@ -296,40 +302,41 @@ function applyInPlace(state, overlay, options, reporter) {
 	}
 }
 /**
-* Applies an Overlay 1.0, 1.1 or 1.2 document to `document` and returns a
-* new document. The input is cloned once with `structuredClone` and never
-* changed; each target runs once through `options.jsonpath`.
+* Applies an Overlay 1.0, 1.1 or 1.2 document to `document` and returns a new
+* document. The input is cloned once with `structuredClone` and never changed;
+* each target runs once through `options.jsonpath`.
 *
-* Actions run in order, each on the result of the previous one (Overlay
-* § 4.5.1.1). `update` merges objects, concatenates or appends to arrays and
+* Actions run in order, each on the result of the previous one (Overlay §
+* 4.5.1.1). `update` merges objects, concatenates or appends to arrays and
 * replaces primitives; `remove` deletes the selected nodes; `copy` (1.1 and
 * later) uses the value of the single node its query selects. Reusable action
-* references (1.2) are expanded, with a warning when the overlay declares
-* 1.0 or 1.1.
+* references (1.2) are expanded, with a warning when the overlay declares 1.0
+* or 1.1.
 *
 * Problems never throw: they are diagnostics, and the failing action is
-* skipped. A target that selects nothing reports `overlay-no-match` as an
-* error unless the action sets `x-better-supabase-allow-empty: true` or the
-* options set `allowEmpty`. The other codes are `overlay-invalid-target`,
-* `overlay-invalid-action`, `overlay-mixed-targets`,
-* `overlay-merge-conflict`, `overlay-copy-source`, `overlay-ref-unresolved`,
-* `overlay-version-feature`, `overlay-version-unsupported` and
-* `overlay-empty-action`.
+* skipped. A target that selects nothing reports `overlay-no-match` as an error
+* unless the action sets `x-better-supabase-allow-empty: true` or the options
+* set `allowEmpty`. The other codes are `overlay-invalid-target`,
+* `overlay-invalid-action`, `overlay-mixed-targets`, `overlay-merge-conflict`,
+* `overlay-copy-source`, `overlay-ref-unresolved`, `overlay-version-feature`,
+* `overlay-version-unsupported` and `overlay-empty-action`.
 *
-* The result keeps the input's type; an overlay that changes the shape
-* needs the caller to narrow it.
+* The result keeps the input's type; an overlay that changes the shape needs
+* the caller to narrow it.
 *
 * @example
-* const jsonpath = await loadJsonPath();
-* const { document, diagnostics } = applyOverlay(openapi, overlay, { jsonpath });
+*   const jsonpath = await loadJsonPath();
+*   const { document, diagnostics } = applyOverlay(openapi, overlay, {
+*     jsonpath,
+*   });
 */
 function applyOverlay(document, overlay, options) {
 	return run(document, [overlay], options, () => "");
 }
 /**
 * Applies overlays in order, each to the result of the previous one, with a
-* single clone of the input. Diagnostic pointers start with the overlay's
-* index (`/1/actions/0`).
+* single clone of the input. Diagnostic pointers start with the overlay's index
+* (`/1/actions/0`).
 */
 function applyOverlays(document, overlays, options) {
 	return run(document, overlays, options, (index) => `/${index}`);
@@ -421,8 +428,8 @@ function equal(a, b) {
 	return false;
 }
 /**
-* Appends the actions that turn the array `a` into `b`, or returns `false`
-* when the change needs the array replaced as a whole.
+* Appends the actions that turn the array `a` into `b`, or returns `false` when
+* the change needs the array replaced as a whole.
 */
 function diffArray(path, a, b, ctx) {
 	if (b.length >= a.length && a.every((item, i) => equal(item, b[i]))) {
@@ -494,15 +501,15 @@ function diffObject(path, a, b, ctx) {
 /**
 * Writes the Overlay that turns `base` into `enriched`, so other tools can
 * reproduce what hooks and transforms changed. Targets use stable keys
-* (`$.paths['/customers'].get`); array indexes appear only inside arrays of
-* the same length.
+* (`$.paths['/customers'].get`); array indexes appear only inside arrays of the
+* same length.
 *
 * A deleted key becomes a `remove` action; added keys become one `update` on
-* their parent; a changed primitive becomes an `update` on it (1.1 and
-* later) or a `remove` and re-add (1.0). An array that only grew gets its new
-* items appended; any other array change replaces the array. Applying the
-* result to `base` gives a document equal to `enriched`, though replaced
-* keys move to the end of their object.
+* their parent; a changed primitive becomes an `update` on it (1.1 and later)
+* or a `remove` and re-add (1.0). An array that only grew gets its new items
+* appended; any other array change replaces the array. Applying the result to
+* `base` gives a document equal to `enriched`, though replaced keys move to the
+* end of their object.
 *
 * Throws a `TypeError` when the roots are not both objects, or when the two
 * documents are equal (an overlay needs at least one action).
@@ -541,10 +548,10 @@ async function load(importer) {
 }
 const cachedEngine = memoized(() => load(importEngine));
 /**
-* Loads the optional `jsonpath-rfc9535` peer, an RFC 9535 implementation
-* that passes the JSONPath Compliance Test Suite, for `applyOverlay`.
-* Rejects with an install message when the package is missing. The engine
-* is loaded once per module; `importer` replaces the import in tests.
+* Loads the optional `jsonpath-rfc9535` peer, an RFC 9535 implementation that
+* passes the JSONPath Compliance Test Suite, for `applyOverlay`. Rejects with
+* an install message when the package is missing. The engine is loaded once per
+* module; `importer` replaces the import in tests.
 */
 function loadJsonPath(importer) {
 	if (importer) return load(importer);

package/dist/payments-BtScsgPS.js

@@ -0,0 +1,16 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { c as isMoney } from "./money-BZl985O-.js";
+//#region src/commerce/payments.ts
+/** Checks the provider's `apiVersion` before a block uses it. */
+function paymentProviderOf(provider) {
+	const version = provider.apiVersion;
+	if (version !== 1) throw new TypeError(`payments "${provider.name}" targets payment provider API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the provider for API 1.`);
+	return provider;
+}
+/** The error for an amount a payment can't carry: not money, or not above zero. */
+function invalidPaymentAmount(amount) {
+	if (!isMoney(amount)) return dbError("invalid_input", "A payment amount is Money: a bigint of minor units and an ISO 4217 currency", { hint: "PAYMENT_AMOUNT_INVALID" });
+	if (amount.amount <= 0n) return dbError("invalid_input", "A payment amount must be more than zero", { hint: "PAYMENT_AMOUNT_INVALID" });
+}
+//#endregion
+export { paymentProviderOf as n, invalidPaymentAmount as t };

package/dist/payments-CBzQIjoX.d.ts

@@ -0,0 +1,114 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-C6jDfedy.js";
+import { n as Money } from "./money-BNRdJQzA.js";
+import { r as WebhookInput } from "./signatures-zbu6KTNQ.js";
+//#region src/commerce/payments.d.ts
+/**
+ * Where a payment stands. `requires_action`: the customer still has to act
+ * (pick a method, confirm, pass 3-D Secure). `authorized`: the funds are held
+ * and wait for `capture`.
+ */
+type PaymentStatus = "requires_action" | "processing" | "authorized" | "succeeded" | "failed" | "canceled";
+interface Payment {
+  /** The provider's id, stored with the order as its payment reference. */
+  readonly id: string;
+  /** The provider's `name`. */
+  readonly provider: string;
+  readonly status: PaymentStatus;
+  readonly amount: Money;
+  /** What was captured so far; zero until the payment succeeds. */
+  readonly captured: Money;
+  /** What was refunded so far. */
+  readonly refunded: Money;
+  /** The order or cart the payment is for, as `createPayment` got it. */
+  readonly reference: string;
+  /**
+   * The secret a client confirms the payment with (Stripe's `client_secret`).
+   * Hand it to the paying browser only; never store or log it.
+   */
+  readonly clientSecret?: string;
+  /** Where to send the customer to finish, when the provider redirects. */
+  readonly redirectUrl?: string;
+  readonly metadata: Readonly<Record<string, string>>;
+}
+interface CreatePaymentInput {
+  /** More than zero, in a currency the provider charges. */
+  readonly amount: Money;
+  /** The order or cart this pays for. Webhook events carry it back. */
+  readonly reference: string;
+  /** `manual` holds the funds until `capture`. Defaults to `automatic`. */
+  readonly capture?: "automatic" | "manual";
+  /** The provider's customer id. */
+  readonly customer?: string;
+  readonly description?: string;
+  /** Where a redirecting payment method returns the customer. */
+  readonly returnUrl?: string;
+  readonly metadata?: Readonly<Record<string, string>>;
+}
+interface PaymentCallOptions {
+  /** The same key returns the first call's result instead of paying twice. */
+  readonly idempotencyKey?: string;
+  readonly signal?: AbortSignal;
+}
+type RefundStatus = "pending" | "succeeded" | "failed" | "canceled";
+interface Refund {
+  readonly id: string;
+  readonly paymentId: string;
+  readonly amount: Money;
+  readonly status: RefundStatus;
+}
+interface RefundInput {
+  /** Defaults to what is left of the captured amount. */
+  readonly amount?: Money;
+  readonly reason?: string;
+}
+type PaymentEventType = "payment.requires_action" | "payment.processing" | "payment.authorized" | "payment.succeeded" | "payment.failed" | "payment.canceled" | "refund.succeeded" | "refund.failed";
+/** A provider's webhook event in one shape for every provider. */
+interface PaymentEvent {
+  /**
+   * The provider's event id. A redelivered event repeats it, so key the
+   * handling on it (the webhook inbox and the `idempotency` module do).
+   */
+  readonly id: string;
+  readonly type: PaymentEventType;
+  readonly paymentId: string;
+  /** The payment's `reference`, when the event carries it. */
+  readonly reference?: string;
+  /** The payment's amount, or the refund's for `refund.*`. */
+  readonly amount?: Money;
+  readonly refundId?: string;
+  readonly occurredAt: Temporal.Instant;
+}
+/**
+ * Takes payments for orders. Versioned: a breaking change ships a new
+ * `apiVersion`. Every method returns a `Result`: `invalid_input` for an amount
+ * the provider can't charge or a refund above what was captured, `not_found`
+ * for an unknown payment, `unauthorized` for a webhook whose signature fails,
+ * and `raised` with the hint `PAYMENT_DECLINED` when the provider declines.
+ */
+interface PaymentProvider {
+  readonly apiVersion: 1;
+  readonly name: string;
+  createPayment(input: CreatePaymentInput, options?: PaymentCallOptions): AsyncResult<Payment>;
+  /** Captures an authorized payment, all of it unless `amount` is less. */
+  capture(paymentId: string, input?: {
+    readonly amount?: Money;
+  }, options?: PaymentCallOptions): AsyncResult<Payment>;
+  refund(paymentId: string, input?: RefundInput, options?: PaymentCallOptions): AsyncResult<Refund>;
+  /**
+   * Verifies a webhook delivery with the provider's secret and returns its
+   * events, none for types the contract doesn't cover.
+   */
+  parseWebhook(input: WebhookInput): AsyncResult<readonly PaymentEvent[]>;
+  /** Releases a payment that was not captured yet. */
+  cancel?(paymentId: string, options?: PaymentCallOptions): AsyncResult<Payment>;
+  get?(paymentId: string, options?: {
+    readonly signal?: AbortSignal;
+  }): AsyncResult<Payment>;
+}
+/** Checks the provider's `apiVersion` before a block uses it. */
+declare function paymentProviderOf(provider: PaymentProvider): PaymentProvider;
+/** The error for an amount a payment can't carry: not money, or not above zero. */
+declare function invalidPaymentAmount(amount: unknown): DbError | undefined;
+//#endregion
+export { PaymentEventType as a, Refund as c, invalidPaymentAmount as d, paymentProviderOf as f, PaymentEvent as i, RefundInput as l, Payment as n, PaymentProvider as o, PaymentCallOptions as r, PaymentStatus as s, CreatePaymentInput as t, RefundStatus as u };

package/dist/permissions-BetA_Fo_.js

@@ -0,0 +1,34 @@
+//#region src/blocks/access/permissions.ts
+/**
+* Whether a granted key covers a wanted one: the same rule as the SQL
+* `permission_matches`, where `*` grants every key and `prefix.*` every key
+* under `prefix`.
+*/
+function permissionMatches(granted, wanted) {
+	return granted === "*" || granted === wanted || granted.endsWith(".*") && wanted.startsWith(granted.slice(0, -1));
+}
+/**
+* Whether `set` holds `key`. UX only: RLS and the SQL functions check the key
+* again.
+*
+* ```ts
+* if (can(permissionSet, permissions.customers.write)) showEditButton();
+* ```
+*/
+function can(set, key) {
+	return set?.keys.some((granted) => permissionMatches(granted, key)) ?? false;
+}
+/**
+* One `can<Name>` boolean per entry of `flags`, for a payload query that
+* returns data and what the caller may do with it.
+*
+* ```ts
+* permissionFlags(set, { edit: permissions.customers.write });
+* // { canEdit: true }
+* ```
+*/
+function permissionFlags(set, flags) {
+	return Object.fromEntries(Object.entries(flags).map(([name, key]) => [`can${name.charAt(0).toUpperCase()}${name.slice(1)}`, can(set, key)]));
+}
+//#endregion
+export { permissionFlags as n, permissionMatches as r, can as t };

package/dist/pg-error-B5QLDcbG.js

@@ -0,0 +1,26 @@
+//#region src/postgres/pg-error.ts
+function isPgError(value) {
+	return typeof value === "object" && value !== null && typeof value.code === "string";
+}
+function retryAfterMsOf(details) {
+	if (typeof details !== "object" || details === null || !("retryAfterMs" in details)) return;
+	const value = details.retryAfterMs;
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Node-postgres error fields to the shape `mapDbError` reads. */
+function fromPgError(error) {
+	if (!isPgError(error)) return;
+	const raw = {};
+	if (error.code !== void 0) raw.code = error.code;
+	if (error.message !== void 0) raw.message = error.message;
+	if (error.detail !== void 0) raw.details = error.detail;
+	if (error.hint !== void 0) raw.hint = error.hint;
+	if (error.constraint !== void 0) raw.constraint = error.constraint;
+	if (error.column !== void 0) raw.column = error.column;
+	if (error.table !== void 0) raw.table = error.table;
+	const retryAfterMs = retryAfterMsOf(error.details);
+	if (retryAfterMs !== void 0) raw.retryAfterMs = retryAfterMs;
+	return raw;
+}
+//#endregion
+export { fromPgError as t };