better-supabase 0.7.1 → 0.9.0

package/dist/comments-D7sbd0xG.js

@@ -0,0 +1,230 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { t as AsyncResult } from "./result-BlgnMB0H.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as stripTypePrefix } from "./cloud-event-CTh9Sr5w.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-CfG_MvDR.js";
+import { r as withBlockHooks } from "./block-hooks-BsXncUlZ.js";
+import { n as blockFields } from "./block-fields-ffD6Gxe4.js";
+import { n as defineListQuery } from "./list-query-CBXNfJt4.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

@@ -0,0 +1,211 @@
+import { f as Result } from "../result-Cj3yWhjH.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-DDZUB_oc.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.
+ */
+export declare const ISO_4217_MINOR_UNITS: Readonly<Record<string, number>>;
+//#endregion
+//#region src/commerce/stripe-payments.d.ts
+type Params$1 = Readonly<Record<string, unknown>>;
+type RequestOptions$1 = {
+  readonly idempotencyKey?: string;
+};
+/** A PaymentIntent, as far as the adapter reads it. */
+interface StripePaymentIntent {
+  readonly id: string;
+  readonly status: string;
+  readonly amount: number;
+  readonly amount_received?: number;
+  readonly currency: string;
+  readonly client_secret?: string | null;
+  readonly metadata?: Readonly<Record<string, string>> | null;
+  readonly next_action?: {
+    readonly redirect_to_url?: {
+      readonly url?: string | null;
+    } | null;
+  } | null;
+  readonly latest_charge?: string | {
+    readonly amount_refunded?: number;
+  } | null;
+}
+interface StripeRefund {
+  readonly id: string;
+  readonly amount: number;
+  readonly currency: string;
+  readonly status?: string | null;
+  readonly payment_intent?: string | {
+    readonly id: string;
+  } | null;
+}
+/**
+ * The part of the Stripe SDK `stripePayments` calls, typed structurally so
+ * the block never imports `stripe`.
+ */
+interface StripePaymentsClient {
+  readonly paymentIntents: {
+    create(params: {
+      readonly amount: number;
+      readonly currency: string;
+      readonly [key: string]: unknown;
+    }, options?: RequestOptions$1): Promise<StripePaymentIntent>;
+    retrieve(id: string, params?: Params$1): Promise<StripePaymentIntent>;
+    capture(id: string, params?: Params$1, options?: RequestOptions$1): Promise<StripePaymentIntent>;
+    cancel(id: string, params?: Params$1, options?: RequestOptions$1): Promise<StripePaymentIntent>;
+  };
+  readonly refunds: {
+    create(params: Params$1, options?: RequestOptions$1): Promise<StripeRefund>;
+  };
+}
+interface StripePaymentsOptions {
+  /**
+   * 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. */
+  readonly webhookSecret: string | readonly string[];
+  /** Defaults to `stripe`. */
+  readonly name?: string;
+  /**
+   * 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`.
+ */
+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.
+ */
+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. */
+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).
+ */
+export declare function fromStripeAmount(amount: number, currency: string): Result<Money>;
+//#endregion
+//#region src/commerce/stripe-tax.d.ts
+type Params = Readonly<Record<string, unknown>>;
+type RequestOptions = {
+  readonly idempotencyKey?: string;
+};
+type CalculationParams = {
+  readonly currency: string;
+  readonly line_items: {
+    readonly amount: number;
+    readonly reference: string;
+    readonly [key: string]: unknown;
+  }[];
+  readonly [key: string]: unknown;
+};
+type ReversalParams = {
+  readonly mode: "full" | "partial";
+  readonly original_transaction: string;
+  readonly reference: string;
+  readonly [key: string]: unknown;
+};
+interface StripeTaxBreakdown {
+  readonly amount: number;
+  readonly jurisdiction?: {
+    readonly display_name?: string | null;
+  } | null;
+  readonly tax_rate_details?: {
+    readonly percentage_decimal?: string | null;
+  } | null;
+}
+interface StripeTaxCalculationLine {
+  readonly id: string;
+  readonly reference: string;
+  readonly amount: number;
+  readonly amount_tax: number;
+  readonly tax_behavior: string;
+  readonly tax_code?: string | null;
+  readonly tax_breakdown?: readonly StripeTaxBreakdown[] | null;
+}
+interface StripeList<T> {
+  readonly data: readonly T[];
+  readonly has_more: boolean;
+}
+interface StripeTaxCalculation {
+  readonly id: string | null;
+  readonly currency: string;
+  readonly expires_at?: number | null;
+  readonly line_items?: StripeList<StripeTaxCalculationLine> | null;
+  readonly shipping_cost?: {
+    readonly amount: number;
+    readonly amount_tax: number;
+    readonly tax_behavior: string;
+    readonly tax_code?: string | null;
+    readonly tax_breakdown?: readonly StripeTaxBreakdown[] | null;
+  } | null;
+}
+interface StripeTaxTransaction {
+  readonly id: string;
+  readonly reference: string;
+}
+interface StripeTaxTransactionLine {
+  readonly id: string;
+  readonly reference: string;
+}
+/**
+ * The part of the Stripe SDK `stripeTax` calls, typed structurally so the
+ * block never imports `stripe`.
+ */
+interface StripeTaxClient {
+  readonly tax: {
+    readonly calculations: {
+      create(params: CalculationParams, options?: RequestOptions): Promise<StripeTaxCalculation>;
+      listLineItems(id: string, params?: Params): PromiseLike<StripeList<StripeTaxCalculationLine>>;
+    };
+    readonly transactions: {
+      createFromCalculation(params: {
+        readonly calculation: string;
+        readonly reference: string;
+      }, options?: RequestOptions): Promise<StripeTaxTransaction>;
+      createReversal(params: ReversalParams, options?: RequestOptions): Promise<StripeTaxTransaction>;
+      listLineItems(id: string, params?: Params): PromiseLike<StripeList<StripeTaxTransactionLine>>;
+    };
+  };
+}
+interface StripeTaxOptions {
+  /**
+   * 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.
+   */
+  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 }`.
+ */
+export declare function stripeTax(options: StripeTaxOptions): TaxProvider;
+//#endregion
+export { type CreatePaymentInput, CurrencyMismatchError, type FixedRatesOptions, type Money, type MoneyJson, type Payment, type PaymentCallOptions, type PaymentEvent, type PaymentEventType, type PaymentProvider, type PaymentStatus, type Refund, type RefundInput, type RefundStatus, SHIPPING_LINE, type StripePaymentIntent, type StripePaymentsClient, type StripePaymentsOptions, type StripeRefund, type StripeTaxCalculation, type StripeTaxCalculationLine, type StripeTaxClient, type StripeTaxOptions, type StripeTaxTransaction, type StripeTaxTransactionLine, type TaxAddress, type TaxCallOptions, type TaxCart, type TaxCartLine, type TaxCommitInput, type TaxLine, type TaxProvider, type TaxQuote, type TaxRates, type TaxReverseInput, type TaxTransaction, addMoney, allocateMoney, applyRate, compareMoney, fixedRates, formatMoney, invalidPaymentAmount, invalidTaxCart, isCurrency, isMoney, isRate, minorUnits, money, moneyFromJson, moneyToJson, multiplyMoney, negateMoney, parseMoney, paymentProviderOf, reversalOf, roundHalfEven, subtractMoney, sumMoney, taxProviderOf, toDecimal };