better-supabase 0.13.0 → 0.15.0

package/dist/client-BAEbEA7t.js

@@ -0,0 +1,287 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { i as specKey, n as claimedTenant, r as sessionUserId, t as hasAuthModule } from "./auth-module-BEFESDC4.js";
+import { r as invalidateTables } from "./user-change-DgWC6RRC.js";
+import { n as liveQuery, t as liveCount } from "./live-C21DgbsD.js";
+//#region src/bindings/client.ts
+/** The caller of the client's auth store. */
+function callerOf(auth) {
+	return {
+		status: auth.status,
+		userId: auth.user?.id ?? null
+	};
+}
+/**
+* The caller of a plain supabase-js client, for subscriptions made without the
+* provider. `loading` until auth-js reports the first state.
+*/
+function plainCaller(supabase) {
+	let caller = {
+		status: "loading",
+		userId: null
+	};
+	return {
+		current: () => caller,
+		subscribe: (listener) => {
+			if (!hasAuthModule(supabase)) {
+				caller = {
+					status: "signed-out",
+					userId: null
+				};
+				return () => void 0;
+			}
+			const { data } = supabase.auth.onAuthStateChange((_event, session) => {
+				caller = {
+					status: session ? "signed-in" : "signed-out",
+					userId: session ? sessionUserId(session) : null
+				};
+				listener();
+			});
+			return () => {
+				data.subscription.unsubscribe();
+			};
+		}
+	};
+}
+/** Throws when `invalidate` has no query client to refetch with. */
+function assertInvalidateClient(hook, options, queryClient) {
+	if (options?.invalidate && !queryClient) throw new Error(`better-supabase: ${hook}({ invalidate }) needs a queryClient on the provider or in the options`);
+}
+/**
+* Subscribes to a topic by its rendered name. Returns the function that leaves,
+* or `undefined` when the name does not match the topic.
+*/
+function startBroadcast(run) {
+	const matched = run.topic.match(run.name);
+	if (!matched) return;
+	const { queryClient } = run;
+	const forward = (payload, message) => {
+		const current = run.latest();
+		const table = current.handlers;
+		(table?.[message.event] ?? table?.["*"])?.(payload, message);
+		const invalidate = current.options?.invalidate;
+		if (!invalidate || !queryClient) return;
+		if (typeof invalidate !== "function") {
+			invalidateTables(queryClient, invalidate);
+			return;
+		}
+		for (const queryKey of invalidate(message)) queryClient.invalidateQueries({ queryKey });
+	};
+	const self = run.latest().options?.self;
+	const subscription = run.topic.subscribe(run.supabase, matched, { "*": forward }, {
+		...self === void 0 ? {} : { self },
+		onStatus: run.onStatus,
+		onInvalid: (message, issues) => run.latest().options?.onInvalid?.(message, issues)
+	});
+	return () => {
+		subscription.unsubscribe();
+		run.onStatus("closed");
+	};
+}
+/** The key a live subscription restarts on: spec, tenant and caller. */
+function liveKey(client, spec, auth, options) {
+	if (!spec || auth.status === "loading") return null;
+	const tenant = options.tenant ?? claimedTenant(auth, client.betterSupabase.meta);
+	return JSON.stringify([
+		specKey(spec),
+		tenant ?? null,
+		auth.user?.id ?? null,
+		options.debounceMs ?? null
+	]);
+}
+/** Invalidates the cached queries that read a table whenever one changes. */
+function startLiveQuery(run) {
+	const { client, queryClient, options } = run;
+	const tenant = options.tenant ?? claimedTenant(run.auth, client.betterSupabase.meta);
+	const userId = run.auth.user?.id ?? null;
+	const live = liveQuery(client.betterSupabase, client.supabase, run.spec, {
+		onChange: (tables) => void invalidateTables(queryClient, tables),
+		onStatus: run.onStatus,
+		...tenant === void 0 ? {} : { tenant },
+		...userId === null ? {} : { user: userId },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+	});
+	if (run.resumed) live.ready.then(() => void invalidateTables(queryClient, live.tables), () => void 0);
+	return () => {
+		live.unsubscribe();
+	};
+}
+/** Splits a count source into its spec and the seed's count and time. */
+function countSource(source, options) {
+	const seed = source && "spec" in source ? source : void 0;
+	return {
+		spec: (seed ? seed.spec : source) ?? null,
+		initial: seed?.count ?? options.initial,
+		seedAt: seed?.at,
+		seeded: seed !== void 0 && seed.count !== null
+	};
+}
+const NO_COUNT = {
+	key: null,
+	count: void 0,
+	at: 0,
+	error: void 0
+};
+/** Refetches the count after each debounced change to a table it reads. */
+function startLiveCount(run) {
+	const { client, key, options } = run;
+	const tenant = options.tenant ?? claimedTenant(run.auth, client.betterSupabase.meta);
+	const userId = run.auth.user?.id ?? null;
+	const live = liveCount(client.betterSupabase, client.supabase, client.db, run.spec, {
+		immediate: run.immediate,
+		...run.since === void 0 ? {} : { since: run.since },
+		onCount: (count) => {
+			const at = Date.now();
+			run.onState(() => ({
+				key,
+				count,
+				at,
+				error: void 0
+			}));
+		},
+		onError: (error) => {
+			run.onState((last) => ({
+				key,
+				count: last.key === key ? last.count : void 0,
+				at: last.key === key ? last.at : 0,
+				error
+			}));
+		},
+		onStatus: run.onStatus,
+		...tenant === void 0 ? {} : { tenant },
+		...userId === null ? {} : { user: userId },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+	});
+	return () => {
+		live.unsubscribe();
+	};
+}
+/** The count to show: the client's, unless a newer server seed arrived. */
+function shownCount(state, key, source) {
+	const fresh = state.key === key;
+	const seedNewer = source.seedAt !== void 0 && source.seeded && source.seedAt > state.at;
+	return {
+		count: fresh && state.count !== void 0 && !seedNewer ? state.count : source.initial,
+		error: fresh ? state.error : void 0
+	};
+}
+const NO_HANDLERS = {};
+/**
+* Joins a presence topic by its rendered name, or `undefined` when it does not
+* match.
+*/
+function joinPresence(supabase, topic, name, handlers) {
+	const matched = topic.match(name);
+	if (!matched) return;
+	const joined = topic.subscribe(supabase, matched, NO_HANDLERS, handlers);
+	let tracked;
+	return {
+		track: async (state) => {
+			const result = await joined.track(state);
+			return result.ok ? void 0 : result.error;
+		},
+		untrack: async () => {
+			const result = await joined.untrack();
+			return result.ok ? void 0 : result.error;
+		},
+		sync(state) {
+			const key = state === void 0 ? void 0 : JSON.stringify(state);
+			if (key === void 0 || key === tracked) return;
+			tracked = key;
+			if (state === null || state === void 0) joined.untrack();
+			else joined.track(state);
+		},
+		leave() {
+			joined.unsubscribe();
+		}
+	};
+}
+/** The error `track` and `untrack` return before the join. */
+const notJoined = () => Promise.resolve(dbError("invalid_request", "better-supabase: the presence topic is not joined"));
+/**
+* Tracks the runs of an action outside React: the inputs in flight, the last
+* data and the last error. `latest` is read on each run, so the action and the
+* callbacks can change between runs.
+*/
+function createActionRunner(latest) {
+	const listeners = /* @__PURE__ */ new Set();
+	let inFlight = [];
+	let data;
+	let error;
+	let state = snapshot();
+	function snapshot() {
+		const pendingInputs = inFlight.map((item) => item.input);
+		return {
+			pending: inFlight.length > 0,
+			pendingInputs,
+			pendingInput: pendingInputs.at(-1),
+			data,
+			error
+		};
+	}
+	const emit = () => {
+		state = snapshot();
+		for (const listener of listeners) listener();
+	};
+	return {
+		current: () => state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		run: async (input) => {
+			const entry = { input };
+			inFlight = [...inFlight, entry];
+			error = void 0;
+			emit();
+			const done = () => {
+				inFlight = inFlight.filter((item) => item !== entry);
+			};
+			const { action, options } = latest();
+			let result;
+			try {
+				result = await action(input);
+			} catch (cause) {
+				done();
+				emit();
+				throw cause;
+			}
+			done();
+			if (result.ok) data = result.data;
+			else error = result.error;
+			emit();
+			if (result.ok) options.onSuccess?.(result.data, input);
+			else options.onError?.(result.error, input);
+			return result;
+		},
+		reset: () => {
+			data = void 0;
+			error = void 0;
+			emit();
+		}
+	};
+}
+/**
+* One run per key: `update` restarts `start` when the key changes and stops the
+* run when the key is `null`.
+*/
+function keyed() {
+	let current;
+	return {
+		update: (key, start) => {
+			if (current?.key === key) return;
+			current?.stop?.();
+			current = key === null ? void 0 : {
+				key,
+				stop: start()
+			};
+		},
+		stop: () => {
+			current?.stop?.();
+			current = void 0;
+		}
+	};
+}
+//#endregion
+export { createActionRunner as a, liveKey as c, shownCount as d, startBroadcast as f, countSource as i, notJoined as l, startLiveQuery as m, assertInvalidateClient as n, joinPresence as o, startLiveCount as p, callerOf as r, keyed as s, NO_COUNT as t, plainCaller as u };

package/dist/cloud-event-CzZTJkXv.d.ts

@@ -0,0 +1,64 @@
+/// <reference lib="esnext.temporal" />
+import { D as BlockEventPattern, T as BlockEvent, o as EventHub } from "./events-vcqenSYU.js";
+//#region src/events/cloud-event.d.ts
+/** A CloudEvents 1.0 event. Extension attributes are lowercase alphanumerics. */
+interface CloudEvent<T = unknown> {
+  readonly specversion: "1.0";
+  readonly id: string;
+  readonly source: string;
+  readonly type: string;
+  readonly subject?: string;
+  readonly time?: string;
+  readonly datacontenttype?: string;
+  readonly dataschema?: string;
+  readonly data?: T;
+  readonly [extension: string]: unknown;
+}
+interface CloudEventOptions {
+  /** URI-reference of the producer, e.g. `https://crm.example.com` or `/crm`. */
+  readonly source: string;
+  /** Replaces the `dev.better-supabase` type prefix. */
+  readonly typePrefix?: string;
+  readonly id?: () => string;
+  readonly now?: () => Temporal.Instant;
+  /**
+   * The `dataschema` attribute: the URI (or `$id`) of the JSON Schema the
+   * event's `data` conforms to, e.g. a schema emitted next to an AsyncAPI
+   * document. A function picks one per event type and leaves it out by
+   * returning `undefined`. Defaults to none.
+   */
+  readonly dataschema?: string | ((event: DataschemaContext) => string | undefined);
+}
+/** What a `dataschema` function sees of an event. */
+interface DataschemaContext {
+  /** The CloudEvents `type`, with the configured prefix. */
+  readonly type: string;
+  /** App key of the mutated table, for row events. */
+  readonly table?: string;
+}
+/** Sends events somewhere: a queue, a bus, an outbox table, an HTTP endpoint. */
+interface EventSink {
+  send(events: readonly CloudEvent[]): void | Promise<void>;
+}
+/**
+ * A block event as a CloudEvent: `dev.better-supabase.support.started` with the
+ * event data and the actor (`actorId`) as `data` and the tenant as
+ * `partitionkey`.
+ */
+declare function blockCloudEvent(event: BlockEvent, options: CloudEventOptions): CloudEvent;
+interface ForwardBlockOptions extends CloudEventOptions {
+  /** Only forward events that match, e.g. `support.*`. Defaults to all. */
+  readonly types?: readonly BlockEventPattern[];
+  /** Sink failures never fail the block call. Defaults to the `Logger`. */
+  readonly onError?: (error: unknown, events: readonly CloudEvent[]) => void;
+}
+/**
+ * Sends a CloudEvent for every block event (`support.*`, `organization.*`, ...)
+ * to `sink`. Returns a function that stops forwarding. Like `forwardMutations`,
+ * sends are tracked on `betterSupabase.events`.
+ */
+declare function forwardBlockEvents(betterSupabase: {
+  readonly events: EventHub;
+}, sink: EventSink, options: ForwardBlockOptions): () => void;
+//#endregion
+export { ForwardBlockOptions as a, EventSink as i, CloudEventOptions as n, blockCloudEvent as o, DataschemaContext as r, forwardBlockEvents as s, CloudEvent as t };

package/dist/codecs-CMWlhHZ0.d.ts

@@ -0,0 +1,222 @@
+/// <reference lib="esnext.temporal" />
+import { i as RowFields } from "./block-fields-BE7pInWZ.js";
+import { n as Money } from "./money-BNRdJQzA.js";
+import { n as Payment } from "./payments-BYcN34Fp.js";
+import { p as TaxTransaction, u as TaxQuote } from "./tax-DPShHual.js";
+//#region src/blocks/orders/codecs.d.ts
+declare const ORDER_STATUSES: readonly ["pending_payment", "paid", "fulfilled", "completed", "cancelled", "refunded"];
+type OrderStatus = (typeof ORDER_STATUSES)[number];
+declare const FULFILLMENT_STATUSES: readonly ["pending", "shipped", "delivered", "cancelled"];
+type FulfillmentStatus = (typeof FULFILLMENT_STATUSES)[number];
+declare const RETURN_STATUSES: readonly ["requested", "received", "rejected"];
+type ReturnStatus = (typeof RETURN_STATUSES)[number];
+declare const REFUND_STATUSES: readonly ["pending", "succeeded", "failed"];
+type OrderRefundStatus = (typeof REFUND_STATUSES)[number];
+/** A postal address; `country` is ISO 3166-1 alpha-2. */
+interface Address {
+  readonly country: string;
+  readonly name?: string;
+  readonly company?: string;
+  readonly line1?: string;
+  readonly line2?: string;
+  readonly postalCode?: string;
+  readonly city?: string;
+  /** The state or province code, such as `CA`. */
+  readonly state?: string;
+  readonly phone?: string;
+}
+/**
+ * Something that keeps a cart from checkout, such as `unpriced` or
+ * `shipping_required`.
+ */
+interface CartProblem {
+  readonly problem: string;
+  readonly lineId?: string;
+  readonly variantId?: string;
+  readonly code?: string;
+  /** For `promotion_unavailable`: the promotion behind the code. */
+  readonly promotionId?: string;
+  /**
+   * For `promotion_unavailable`, such as `expired`, `limit_reached` or
+   * `not_combinable`.
+   */
+  readonly reason?: string;
+}
+interface CartLine {
+  readonly id: string;
+  readonly variantId: string;
+  readonly productId: string;
+  readonly sku: string;
+  readonly title: string;
+  readonly quantity: number;
+  readonly unitAmount: Money;
+  /** The price when the line was added, when it changed since. */
+  readonly previousUnitAmount?: Money;
+  readonly subtotal: Money;
+  readonly discount: Money;
+  /** After discounts, before tax. */
+  readonly total: Money;
+  readonly requiresShipping: boolean;
+}
+declare const PROMOTION_KINDS: readonly ["percentage", "fixed", "free_shipping"];
+/** A promotion the cart gets, as the `promotions` module reports it. */
+interface AppliedPromotion {
+  readonly promotionId: string;
+  readonly name: string;
+  readonly kind: (typeof PROMOTION_KINDS)[number];
+  readonly code?: string;
+  /** Zero for free shipping, which shows in the shipping total instead. */
+  readonly discount: Money;
+  readonly freeShipping: boolean;
+}
+interface PricedCart {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly customerId: string;
+  readonly status: "open" | "converted" | "abandoned";
+  readonly currency: string;
+  readonly email?: string;
+  readonly shippingAddress?: Address;
+  readonly billingAddress?: Address;
+  readonly lines: readonly CartLine[];
+  readonly subtotal: Money;
+  readonly discountTotal: Money;
+  readonly shippingTotal: Money;
+  /** Subtotal less discounts plus shipping, before tax. */
+  readonly total: Money;
+  readonly requiresShipping: boolean;
+  readonly weightGrams: number;
+  readonly shipping?: {
+    readonly rateId: string;
+    readonly name: string;
+    readonly amount: Money;
+  };
+  readonly promotions: readonly AppliedPromotion[];
+  /** Empty when the cart can check out. */
+  readonly problems: readonly CartProblem[];
+}
+interface ShippingOption {
+  readonly id: string;
+  readonly name: string;
+  readonly kind: "flat" | "weight";
+  readonly amount: Money;
+}
+interface OrderLine {
+  readonly id: string;
+  /** Null once the variant is deleted; the line keeps its SKU and title. */
+  readonly variantId: string | null;
+  readonly productId: string | null;
+  readonly sku: string;
+  readonly title: string;
+  readonly quantity: number;
+  readonly unitAmount: Money;
+  readonly subtotal: Money;
+  readonly discount: Money;
+  readonly tax: Money;
+  /** After discounts, without tax. */
+  readonly total: Money;
+  readonly requiresShipping: boolean;
+  readonly locationId: string | null;
+  readonly reservationId: string | null;
+  readonly fulfilled: number;
+  readonly returned: number;
+  /** The stock didn't cover the line when the order was placed or paid. */
+  readonly backordered: boolean;
+}
+interface OrderPayment {
+  readonly id: string;
+  readonly provider: string;
+  /** The provider's payment id. */
+  readonly reference: string;
+  readonly status: Payment["status"];
+  readonly amount: Money;
+  readonly captured: Money;
+  readonly refunded: Money;
+  readonly createdAt: Temporal.Instant;
+}
+interface QuantityLine {
+  readonly lineId: string;
+  readonly quantity: number;
+}
+interface Fulfillment {
+  readonly id: string;
+  readonly status: FulfillmentStatus;
+  readonly locationId: string | null;
+  readonly carrier: string | null;
+  readonly trackingNumber: string | null;
+  readonly trackingUrl: string | null;
+  readonly lines: readonly QuantityLine[];
+  readonly createdAt: Temporal.Instant;
+  readonly shippedAt?: Temporal.Instant;
+  readonly deliveredAt?: Temporal.Instant;
+}
+interface OrderReturn {
+  readonly id: string;
+  readonly status: ReturnStatus;
+  readonly reason: string | null;
+  readonly lines: readonly QuantityLine[];
+  readonly createdAt: Temporal.Instant;
+  readonly receivedAt?: Temporal.Instant;
+}
+interface OrderRefund {
+  readonly id: string;
+  readonly paymentId: string;
+  readonly returnId: string | null;
+  readonly amount: Money;
+  readonly status: OrderRefundStatus;
+  readonly reason: string | null;
+  readonly providerReference: string | null;
+  readonly createdAt: Temporal.Instant;
+  readonly completedAt?: Temporal.Instant;
+}
+/** An order. `F` types the extra columns the `fields` schema describes. */
+interface Order<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  /** Gapless per organization, from `numbering` when it numbers `order`. */
+  readonly number: string;
+  readonly cartId: string;
+  readonly customerId: string;
+  readonly email: string | null;
+  readonly status: OrderStatus;
+  readonly currency: string;
+  readonly subtotal: Money;
+  readonly discountTotal: Money;
+  readonly shippingTotal: Money;
+  readonly taxTotal: Money;
+  /** What the customer pays: with tax, unless the prices already include it. */
+  readonly total: Money;
+  readonly paidTotal: Money;
+  readonly refundedTotal: Money;
+  readonly taxInclusive: boolean;
+  readonly shippingAddress?: Address;
+  readonly billingAddress?: Address;
+  readonly shipping?: {
+    readonly rateId: string;
+    readonly name: string;
+    readonly amount: Money;
+  };
+  readonly promotions: readonly AppliedPromotion[];
+  /** The tax quote the order was placed with. */
+  readonly taxQuote?: TaxQuote;
+  /** The sale the tax provider recorded once the order was paid. */
+  readonly taxTransaction?: TaxTransaction;
+  /** Gapless per organization; set once the order is paid. */
+  readonly invoiceNumber: string | null;
+  readonly invoicedAt?: Temporal.Instant;
+  readonly placedAt: Temporal.Instant;
+  readonly paidAt?: Temporal.Instant;
+  readonly fulfilledAt?: Temporal.Instant;
+  readonly completedAt?: Temporal.Instant;
+  readonly cancelledAt?: Temporal.Instant;
+  readonly cancelReason: string | null;
+  readonly lines: readonly OrderLine[];
+  readonly payments: readonly OrderPayment[];
+  readonly fulfillments: readonly Fulfillment[];
+  readonly returns: readonly OrderReturn[];
+  readonly refunds: readonly OrderRefund[];
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+//#endregion
+export { ShippingOption as S, PricedCart as _, FULFILLMENT_STATUSES as a, RETURN_STATUSES as b, ORDER_STATUSES as c, OrderPayment as d, OrderRefund as f, PROMOTION_KINDS as g, OrderStatus as h, CartProblem as i, Order as l, OrderReturn as m, AppliedPromotion as n, Fulfillment as o, OrderRefundStatus as p, CartLine as r, FulfillmentStatus as s, Address as t, OrderLine as u, QuantityLine as v, ReturnStatus as x, REFUND_STATUSES as y };