better-supabase 0.8.0 → 0.9.0

package/dist/tanstack-db/supabase/index.js

@@ -1,16 +1,190 @@
 import { t as DbException } from "../../db-exception-CnWcYPxL.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
 import { supabaseCollectionOptions } from "@supabase-labs/tanstack-db";
+//#region src/tanstack-db/supabase/table-client.ts
+const PLAIN_PARAMS = /* @__PURE__ */ new Set(["limit", "offset"]);
+const LIST_PARAMS = /* @__PURE__ */ new Set([
+	"columns",
+	"on_conflict",
+	"order",
+	"select"
+]);
+const LOGIC_PARAM = /^(not\.)?(and|or)$/;
+function renameRows(value, names) {
+	if (Array.isArray(value)) return value.map((row) => renameRows(row, names));
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [names.get(key) ?? key, item]));
+}
+/** Index of the first `,` or `)` outside quotes and nested parentheses. */
+function valueEnd(text, start) {
+	let depth = 0;
+	let quoted = false;
+	let index = start;
+	for (; index < text.length; index += 1) {
+		const char = text[index];
+		if (quoted) {
+			if (char === "\\") index += 1;
+			else if (char === "\"") quoted = false;
+		} else if (char === "\"") quoted = true;
+		else if (char === "(") depth += 1;
+		else if (char === ")") {
+			if (depth === 0) break;
+			depth -= 1;
+		} else if (char === "," && depth === 0) break;
+	}
+	return index;
+}
+/** Renames the columns in a PostgREST logic tree: `(a.eq.1,and(b.gt.2,c.is.null))`. */
+function renameLogic(text, rename) {
+	let out = "";
+	let index = 0;
+	while (index < text.length) {
+		const char = text[index];
+		if (char === "(" || char === ")" || char === ",") {
+			out += char;
+			index += 1;
+			continue;
+		}
+		let end = index;
+		while (end < text.length && !".(),".includes(text[end] ?? "")) end += 1;
+		const token = text.slice(index, end);
+		if (text[end] === "(") {
+			out += token;
+			index = end;
+		} else if (token === "not" && /^\.(and|or)\(/.test(text.slice(end))) {
+			out += "not.";
+			index = end + 1;
+		} else {
+			const stop = valueEnd(text, end);
+			out += rename(token) + text.slice(end, stop);
+			index = stop;
+		}
+	}
+	return out;
+}
+/** Renames the head of `column.asc`, `alias:column.sum()` or `column::text`. */
+function renameHead(item, rename) {
+	const colon = /^[^.:(]*:(?!:)/.exec(item)?.[0] ?? "";
+	const rest = item.slice(colon.length);
+	const head = /^[^.:(]*/.exec(rest)?.[0] ?? "";
+	return colon + rename(head) + rest.slice(head.length);
+}
+function renameSearch(search, rename) {
+	const out = new URLSearchParams();
+	for (const [key, value] of search) if (PLAIN_PARAMS.has(key)) out.append(key, value);
+	else if (LIST_PARAMS.has(key)) out.append(key, value.split(",").map((item) => renameHead(item, rename)).join(","));
+	else if (LOGIC_PARAM.test(key)) out.append(key, renameLogic(value, rename));
+	else out.append(rename(key), value);
+	return out;
+}
+/** Renames the columns in a Realtime filter list: `a=eq.1,b=in.("x,y")`. */
+function renameRealtimeFilter(text, rename) {
+	let out = "";
+	let index = 0;
+	while (index < text.length) {
+		const equals = text.indexOf("=", index);
+		if (equals === -1) return out + text.slice(index);
+		const stop = valueEnd(text, equals + 1);
+		const tail = text[stop] === "," ? stop : text.length;
+		out += rename(text.slice(index, equals)) + text.slice(equals, tail);
+		index = tail;
+		if (text[index] === ",") {
+			out += ",";
+			index += 1;
+		}
+	}
+	return out;
+}
+function renamingFetch(inner, rename, toApp, toDb) {
+	return async (input, init) => {
+		const url = new URL(input instanceof Request ? input.url : String(input));
+		url.search = renameSearch(url.searchParams, rename).toString();
+		const request = typeof init?.body === "string" && init.body !== "" ? {
+			...init,
+			body: JSON.stringify(renameRows(JSON.parse(init.body), toDb))
+		} : { ...init };
+		const response = await inner(url.toString(), request);
+		const type = response.headers.get("content-type") ?? "";
+		if (!response.ok || !type.includes("json")) return response;
+		const text = await response.text();
+		return new Response(text === "" ? null : JSON.stringify(renameRows(JSON.parse(text), toApp)), {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+	};
+}
+function bound(target, prop) {
+	const value = target[prop];
+	return typeof value === "function" ? value.bind(target) : value;
+}
+/**
+* The client `@supabase-labs/tanstack-db` sees for one table: requests and
+* Realtime listeners run in the table's schema, and when app names differ
+* from column names, rows arrive in app names and leave in column names.
+*/
+function tableClient(supabase, table) {
+	const toDb = /* @__PURE__ */ new Map();
+	const toApp = /* @__PURE__ */ new Map();
+	for (const [name, column] of Object.entries(table.columns)) if (name !== column.db) {
+		toDb.set(name, column.db);
+		toApp.set(column.db, name);
+	}
+	if (table.schema === "public" && toDb.size === 0) return supabase;
+	const rename = (name) => toDb.get(name) ?? name;
+	const channels = /* @__PURE__ */ new WeakMap();
+	const from = (name) => {
+		const builder = table.schema === "public" ? supabase.from(name) : supabase.schema(table.schema).from(name);
+		if (toDb.size === 0) return builder;
+		const fetch = renamingFetch(builder.fetch ?? globalThis.fetch, rename, toApp, toDb);
+		return new Proxy(builder, { get: (target, prop) => prop === "fetch" ? fetch : bound(target, prop) });
+	};
+	const channel = (...args) => {
+		const real = supabase.channel(...args);
+		const proxy = new Proxy(real, { get: (target, prop) => {
+			if (prop !== "on") return bound(target, prop);
+			return (type, filter, callback) => {
+				if (type !== "postgres_changes") {
+					target.on(type, filter, callback);
+					return proxy;
+				}
+				const scoped = {
+					...filter,
+					schema: table.schema,
+					...filter.filter === void 0 ? {} : { filter: renameRealtimeFilter(filter.filter, rename) }
+				};
+				target.on(type, scoped, (payload) => {
+					callback({
+						...payload,
+						new: renameRows(payload.new, toApp),
+						old: renameRows(payload.old, toApp)
+					});
+				});
+				return proxy;
+			};
+		} });
+		channels.set(proxy, real);
+		return proxy;
+	};
+	const removeChannel = (proxy) => supabase.removeChannel(channels.get(proxy) ?? proxy);
+	const overrides = /* @__PURE__ */ new Map([
+		["from", from],
+		["channel", channel],
+		["removeChannel", removeChannel]
+	]);
+	return new Proxy(supabase, { get: (target, prop) => overrides.has(prop) ? overrides.get(prop) : bound(target, prop) });
+}
+//#endregion
 //#region src/tanstack-db/supabase/collection.ts
 function field(row, name) {
-	if (typeof row !== "object" || row === null || !(name in row)) return void 0;
+	if (typeof row !== "object" || row === null || !(name in row)) return;
 	return Object.getOwnPropertyDescriptor(row, name)?.value;
 }
 /**
 * A TanStack DB collection on `@supabase-labs/tanstack-db`: live queries load
 * on demand through PostgREST, Realtime keeps them current, and writes go
-* through the table's repository by default. Rows use database column names,
-* so the schema must use `casing: "snake"`, and the table must live in the
-* `public` schema, which is the one the Realtime listener watches.
+* through the table's repository by default. Rows use the configured casing,
+* and requests and Realtime listeners run in the table's own schema.
 *
 * ```ts
 * const customers = createCollection(
@@ -23,11 +197,8 @@ function field(row, name) {
 * ```
 */
 function supabaseCollection(betterSupabase, supabase, table, options) {
-	const { meta } = betterSupabase;
-	if (meta.casing !== "snake") throw new TypeError(`better-supabase: supabaseCollection() needs casing: "snake"; @supabase-labs/tanstack-db reads and writes database column names. Use collectionOptions() with camel casing.`);
-	const tableMeta = meta.tables[table];
+	const tableMeta = betterSupabase.meta.tables[table];
 	if (!tableMeta) throw new TypeError(`better-supabase: unknown table "${table}"`);
-	if (tableMeta.schema !== "public") throw new TypeError(`better-supabase: supabaseCollection() supports tables in the public schema; "${tableMeta.schema}.${tableMeta.name}" is not.`);
 	const primaryKey = tableMeta.primaryKey;
 	const [single] = primaryKey;
 	if (single === void 0) throw new TypeError(`better-supabase: the "${table}" collection needs a table with a primary key`);
@@ -35,7 +206,7 @@ function supabaseCollection(betterSupabase, supabase, table, options) {
 		tableName: tableMeta.name,
 		keys: [...primaryKey],
 		schema: options.schema,
-		supabase,
+		supabase: tableClient(supabase, tableMeta),
 		...options.queryClient ? { queryClient: options.queryClient } : {},
 		...options.realtime === void 0 ? {} : { realtime: options.realtime },
 		...options.realtimeUseFilter === void 0 ? {} : { realtimeUseFilter: options.realtimeUseFilter }

package/dist/tanstack-start/index.d.ts

@@ -1,9 +1,9 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-CoE5Zwy4.js";
-import { t as BetterSupabase } from "../define-DmcfoNXB.js";
-import { t as BetterServer } from "../server-types-CrAmZ8jv.js";
-import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-W99LCPBS.js";
-import { t as RefusalRedirects } from "../refusal-CFI8-5nf.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-148t1m3C.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-YfwpIE-d.js";
+import { t as BetterSupabase } from "../define-DxHHbNEb.js";
+import { t as BetterServer } from "../server-types-OohhIQb2.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-D5S7KNFe.js";
+import { t as RefusalRedirects } from "../refusal-oD3ISM9h.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-DG5Bv39u.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
@@ -13,7 +13,7 @@ interface TanStackStartServerArgs<Context, Result> {
   readonly request: Request;
   readonly next: (options: {
     readonly context: Context;
-  }) => Promise<Result>;
+  }) => Promise<Result> | Result;
 }
 interface ToTanStackStartOptions {
   /** The host's env object for `getEnv`, read per request. */

package/dist/tanstack-start/index.js

@@ -1,9 +1,9 @@
-import { c as extendServer, o as withFlush, s as createServer } from "../adapter-CN45ibbV.js";
-import { t as defaultExpose } from "../respond-volM3ByS.js";
-import { i as requireCaller, o as runAction } from "../kit-BhHr9T9v.js";
-import { n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
-import { i as localsOf, r as frameworkEntry } from "../framework-3ey3QmrO.js";
-import { r as refusalResponse } from "../refusal-K78A1Vmq.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-CEjmtazZ.js";
+import { t as defaultExpose } from "../respond-DdhZ9Wbn.js";
+import { i as requireCaller, o as runAction } from "../kit-MUK34-ZG.js";
+import { n as bufferInPlace, t as around } from "../shared-BmMcMoW9.js";
+import { i as localsOf, r as frameworkEntry } from "../framework-INbjMZX1.js";
+import { r as refusalResponse } from "../refusal-br4Ma9Cf.js";
 //#region src/bridges/tanstack-start.ts
 /** The `response` of a request middleware's `next()` result; server function results have none. */
 function responseOf(result) {

package/dist/tax-DDZUB_oc.d.ts

@@ -0,0 +1,273 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, f as Result, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { r as WebhookInput } from "./signatures-BMdJ7neI.js";
+import { n as Money } from "./money-DFpWzQvk.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
+//#region src/commerce/tax.d.ts
+/** Where the goods go (or the customer is, for services). */
+interface TaxAddress {
+  /** ISO 3166-1 alpha-2, such as `NL`. */
+  readonly country: string;
+  /** The state or province code, such as `CA`. */
+  readonly state?: string;
+  readonly postalCode?: string;
+  readonly city?: string;
+  readonly line1?: string;
+  readonly line2?: string;
+}
+interface TaxCartLine {
+  /** The cart line's id; the quote's line for it carries the same `lineId`. */
+  readonly id: string;
+  /** The line's total after discounts, in the cart's currency. */
+  readonly amount: Money;
+  readonly quantity?: number;
+  /** The product's tax category: a key of the provider's rates or a provider tax code. */
+  readonly taxCategory?: string;
+  /** The amount already contains the tax (prices shown with VAT). */
+  readonly inclusive?: boolean;
+}
+interface TaxCart {
+  readonly currency: string;
+  readonly lines: readonly TaxCartLine[];
+  readonly shipping?: {
+    readonly amount: Money;
+    readonly taxCategory?: string;
+    readonly inclusive?: boolean;
+  };
+  readonly address: TaxAddress;
+  readonly customer?: {
+    /** The provider's customer id. */
+    readonly id?: string;
+    /** No tax at all, such as a reverse-charged B2B sale. */
+    readonly exempt?: boolean;
+  };
+  /** The cart or order the quote is for. */
+  readonly reference?: string;
+}
+/** The lineId of the shipping line in a quote. */
+declare const SHIPPING_LINE = "shipping";
+interface TaxLine {
+  /** The cart line's `id`, or `SHIPPING_LINE`. */
+  readonly lineId: string;
+  /** The amount the tax is computed on, without the tax. */
+  readonly taxable: Money;
+  readonly tax: Money;
+  /** The decimal fraction applied, such as `"0.21"`. */
+  readonly rate: string;
+  readonly inclusive: boolean;
+  /** The jurisdiction: Stripe's name (`Netherlands`) or the `fixedRates` region (`NL`). */
+  readonly jurisdiction?: string;
+  readonly taxCategory?: string;
+}
+interface TaxQuote {
+  /** The provider's id for the calculation; `commit` turns it into a transaction. */
+  readonly id: string;
+  /** The provider's `name`. */
+  readonly provider: string;
+  readonly currency: string;
+  /** One per cart line, in cart order, then the shipping line when there is one. */
+  readonly lines: readonly TaxLine[];
+  /** The tax of every line, shipping included. */
+  readonly totalTax: Money;
+  /** When the provider stops accepting the quote for `commit`. */
+  readonly expiresAt?: Temporal.Instant;
+}
+/** A recorded sale or reversal. Store it with the order to reverse it later. */
+interface TaxTransaction {
+  readonly id: string;
+  /** The order number for a sale, the refund's id for a reversal. */
+  readonly reference: string;
+  readonly currency: string;
+  /** Negative for a reversal. */
+  readonly totalTax: Money;
+  readonly lines: readonly TaxLine[];
+}
+interface TaxCommitInput {
+  readonly quote: TaxQuote;
+  /** The order number, unique per sale. */
+  readonly reference: string;
+}
+interface TaxReverseInput {
+  /** The sale `commit` returned. */
+  readonly transaction: TaxTransaction;
+  /** The refund's id, unique per reversal. */
+  readonly reference: string;
+  /**
+   * The refunded part of each line, as positive amounts without tax and
+   * their tax. Unset: the whole sale is reversed.
+   */
+  readonly lines?: readonly {
+    readonly lineId: string;
+    readonly amount: Money;
+    readonly tax: Money;
+  }[];
+}
+interface TaxCallOptions {
+  /** The same key returns the first call's result instead of recording twice. */
+  readonly idempotencyKey?: string;
+  readonly signal?: AbortSignal;
+}
+/**
+ * Computes and records sales tax. Versioned: a breaking change ships a new
+ * `apiVersion`. Every method returns a `Result`: `invalid_input` for a cart
+ * that mixes currencies or a reversal above the sale, and `not_found` for
+ * an address the provider has no rate for.
+ */
+interface TaxProvider {
+  readonly apiVersion: 1;
+  readonly name: string;
+  quote(cart: TaxCart, options?: TaxCallOptions): AsyncResult<TaxQuote>;
+  commit(input: TaxCommitInput, options?: TaxCallOptions): AsyncResult<TaxTransaction>;
+  reverse(input: TaxReverseInput, options?: TaxCallOptions): AsyncResult<TaxTransaction>;
+}
+/** Checks the provider's `apiVersion` before a block uses it. */
+declare function taxProviderOf(provider: TaxProvider): TaxProvider;
+/**
+ * The first problem with a cart: a line or shipping amount that isn't
+ * money, is negative or is in another currency, or a country that isn't
+ * two capital letters.
+ */
+declare function invalidTaxCart(cart: TaxCart): DbError | undefined;
+/** The lines and total of a reversal, checked against the sale. */
+declare function reversalOf(input: TaxReverseInput): Result<{
+  readonly lines: readonly TaxLine[];
+  readonly totalTax: Money;
+}>;
+/** Rates per tax category, such as `{ standard: "0.21", reduced: "0.09" }`. */
+type TaxRates = Readonly<Record<string, string>>;
+interface FixedRatesOptions {
+  /** Defaults to `fixed-rates`. */
+  readonly name?: string;
+  /**
+   * Rates per region: a country code (`NL`) or a country and state
+   * (`US-CA`), which wins over its country.
+   */
+  readonly rates: Readonly<Record<string, TaxRates>>;
+  /** The category of a line without one. Defaults to `standard`. */
+  readonly defaultCategory?: string;
+  /** The category of shipping. Defaults to `defaultCategory`. */
+  readonly shippingCategory?: string;
+  /**
+   * A region without rates: `error` returns `not_found` (the default),
+   * `zero` quotes no tax.
+   */
+  readonly unknownRegion?: "error" | "zero";
+}
+/**
+ * A `TaxProvider` with fixed rates per country (and state) and tax
+ * category, rounded half to even per line. It keeps nothing: `commit` and
+ * `reverse` return the transaction for the app to store.
+ */
+declare function fixedRates(options: FixedRatesOptions): TaxProvider;
+//#endregion
+export { PaymentProvider as C, RefundStatus as D, RefundInput as E, invalidPaymentAmount as O, PaymentEventType as S, Refund as T, taxProviderOf as _, TaxCart as a, PaymentCallOptions as b, TaxLine as c, TaxRates as d, TaxReverseInput as f, reversalOf as g, invalidTaxCart as h, TaxCallOptions as i, paymentProviderOf as k, TaxProvider as l, fixedRates as m, SHIPPING_LINE as n, TaxCartLine as o, TaxTransaction as p, TaxAddress as r, TaxCommitInput as s, FixedRatesOptions as t, TaxQuote as u, CreatePaymentInput as v, PaymentStatus as w, PaymentEvent as x, Payment as y };

package/dist/tax-D_kSCdWU.js

@@ -0,0 +1,140 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-BlgnMB0H.js";
+import { c as isMoney, h as negateMoney, i as applyRate, l as isRate, v as subtractMoney, y as sumMoney } from "./money-95Rff2vT.js";
+//#region src/commerce/tax.ts
+/** The lineId of the shipping line in a quote. */
+const SHIPPING_LINE = "shipping";
+/** Checks the provider's `apiVersion` before a block uses it. */
+function taxProviderOf(provider) {
+	const version = provider.apiVersion;
+	if (version !== 1) throw new TypeError(`tax "${provider.name}" targets tax provider API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the provider for API 1.`);
+	return provider;
+}
+const invalid = (message, hint) => dbError("invalid_input", message, { hint });
+/**
+* The first problem with a cart: a line or shipping amount that isn't
+* money, is negative or is in another currency, or a country that isn't
+* two capital letters.
+*/
+function invalidTaxCart(cart) {
+	if (!/^[A-Z]{2}$/.test(cart.address.country)) return invalid(`"${cart.address.country}" is not an ISO 3166-1 alpha-2 country code`, "TAX_ADDRESS_INVALID");
+	const amounts = [...cart.lines.map((line) => line.amount), ...cart.shipping ? [cart.shipping.amount] : []];
+	for (const amount of amounts) {
+		if (!isMoney(amount) || amount.amount < 0n) return invalid("Every cart line is Money of zero or more", "TAX_AMOUNT_INVALID");
+		if (amount.currency !== cart.currency) return invalid(`A ${amount.currency} line in a ${cart.currency} cart: lines never mix currencies`, "TAX_CURRENCY_MISMATCH");
+	}
+}
+/** The lines and total of a reversal, checked against the sale. */
+function reversalOf(input) {
+	const { transaction } = input;
+	if (input.lines === void 0) {
+		const lines = transaction.lines.map((line) => ({
+			...line,
+			taxable: negateMoney(line.taxable),
+			tax: negateMoney(line.tax)
+		}));
+		return ok({
+			lines,
+			totalTax: negateMoney(transaction.totalTax)
+		});
+	}
+	const byId = new Map(transaction.lines.map((line) => [line.lineId, line]));
+	const lines = [];
+	for (const part of input.lines) {
+		const sold = byId.get(part.lineId);
+		if (sold === void 0) return err(invalid(`The sale has no line "${part.lineId}"`, "TAX_REVERSAL_UNKNOWN_LINE"));
+		if (!isMoney(part.amount) || !isMoney(part.tax) || part.amount.currency !== transaction.currency || part.tax.currency !== transaction.currency || part.amount.amount < 0n || part.tax.amount < 0n || part.tax.amount > sold.tax.amount || part.amount.amount > sold.taxable.amount) return err(invalid(`The reversal of "${part.lineId}" is not a part of the sold line in ${transaction.currency}`, "TAX_REVERSAL_TOO_LARGE"));
+		lines.push({
+			...sold,
+			taxable: negateMoney(part.amount),
+			tax: negateMoney(part.tax)
+		});
+	}
+	return ok({
+		lines,
+		totalTax: sumMoney(lines.map((line) => line.tax), transaction.currency)
+	});
+}
+/**
+* A `TaxProvider` with fixed rates per country (and state) and tax
+* category, rounded half to even per line. It keeps nothing: `commit` and
+* `reverse` return the transaction for the app to store.
+*/
+function fixedRates(options) {
+	for (const [region, rates] of Object.entries(options.rates)) {
+		if (!/^[A-Z]{2}(-[A-Z0-9]{1,3})?$/.test(region)) throw new TypeError(`fixedRates: "${region}" is not a country code (NL) or a country and state (US-CA)`);
+		for (const [category, rate] of Object.entries(rates)) if (!isRate(rate)) throw new TypeError(`fixedRates: the ${region} "${category}" rate "${String(rate)}" is not a decimal fraction such as "0.21"`);
+	}
+	const name = options.name ?? "fixed-rates";
+	const defaultCategory = options.defaultCategory ?? "standard";
+	const shippingCategory = options.shippingCategory ?? defaultCategory;
+	const regionFor = (address) => {
+		const keys = [...address.state === void 0 ? [] : [`${address.country}-${address.state}`], address.country];
+		for (const region of keys) {
+			const rates = options.rates[region];
+			if (rates !== void 0) return {
+				region,
+				rates
+			};
+		}
+	};
+	const lineOf = (lineId, amount, category, inclusive, region, exempt) => {
+		const rate = exempt || region === void 0 ? "0" : region.rates[category];
+		if (rate === void 0) return err(dbError("not_found", `No "${category}" tax rate for this region`, { hint: "TAX_RATE_UNKNOWN" }));
+		const tax = applyRate(amount, rate, { included: inclusive });
+		return ok({
+			lineId,
+			taxable: inclusive ? subtractMoney(amount, tax) : amount,
+			tax,
+			rate,
+			inclusive,
+			...region === void 0 ? {} : { jurisdiction: region.region },
+			taxCategory: category
+		});
+	};
+	return {
+		apiVersion: 1,
+		name,
+		quote: (cart) => AsyncResult.from(() => Promise.resolve(quoteOf(cart))),
+		commit: ({ quote, reference }) => AsyncResult.ok({
+			id: quote.id,
+			reference,
+			currency: quote.currency,
+			totalTax: quote.totalTax,
+			lines: quote.lines
+		}),
+		reverse: (input) => AsyncResult.from(() => Promise.resolve(reversalOf(input))).map((reversal) => ({
+			id: `${input.transaction.id}:${input.reference}`,
+			reference: input.reference,
+			currency: input.transaction.currency,
+			...reversal
+		}))
+	};
+	function quoteOf(cart) {
+		const problem = invalidTaxCart(cart);
+		if (problem) return err(problem);
+		const rates = regionFor(cart.address);
+		if (rates === void 0 && options.unknownRegion !== "zero") return err(dbError("not_found", `No tax rates for ${cart.address.country}${cart.address.state ? `-${cart.address.state}` : ""}`, { hint: "TAX_REGION_UNKNOWN" }));
+		const exempt = cart.customer?.exempt === true;
+		const lines = [];
+		for (const line of cart.lines) {
+			const taxed = lineOf(line.id, line.amount, line.taxCategory ?? defaultCategory, line.inclusive === true, rates, exempt);
+			if (!taxed.ok) return taxed;
+			lines.push(taxed.data);
+		}
+		if (cart.shipping) {
+			const taxed = lineOf(SHIPPING_LINE, cart.shipping.amount, cart.shipping.taxCategory ?? shippingCategory, cart.shipping.inclusive === true, rates, exempt);
+			if (!taxed.ok) return taxed;
+			lines.push(taxed.data);
+		}
+		return ok({
+			id: `fixed_${crypto.randomUUID()}`,
+			provider: name,
+			currency: cart.currency,
+			lines,
+			totalTax: sumMoney(lines.map((line) => line.tax), cart.currency)
+		});
+	}
+}
+//#endregion
+export { taxProviderOf as a, reversalOf as i, fixedRates as n, invalidTaxCart as r, SHIPPING_LINE as t };