better-supabase 0.8.0 → 0.9.0

package/dist/blocks/reminders/index.js

@@ -0,0 +1,171 @@
+import { n as dbError, o as isDbError } from "../../errors-8i6tSICm.js";
+import { t as temporal } from "../../temporal-required-DqRzr7i0.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { t as subjectReaders } from "../../subject-readers-DiePmaYP.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { l as writeFields, n as blockFields, o as readFields, s as rowFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as allowedSubscribers } from "../../subscribers-Cq--DL1E.js";
+import { n as weekdayName, t as expandRule } from "../../rrule-zBh3CA1r.js";
+import { t as remindersSqlOptions } from "../../options-DARkpk2P.js";
+//#region src/blocks/reminders/schedule.ts
+/**
+* Expands each rule between `from` and `until` and returns one delivery per
+* occurrence, shifted earlier by `offsetMinutes`. The caller enqueues each
+* row as a delayed `reminders.deliver` job with `dedupeKey`.
+*/
+function planReminderDeliveries(items, window) {
+	const time = temporal();
+	const planned = [];
+	for (const item of items) {
+		const occurrences = expandRule({
+			dtstart: item.dtstart,
+			...item.rrule === void 0 ? {} : { rrule: item.rrule },
+			...item.columns === void 0 ? {} : { columns: item.columns },
+			limit: 366
+		});
+		for (const occurrence of occurrences) {
+			const runAt = occurrence.subtract({ minutes: item.offsetMinutes });
+			if (time.ZonedDateTime.compare(runAt, window.from) < 0) continue;
+			if (time.ZonedDateTime.compare(runAt, window.until) > 0) continue;
+			const occurrenceAt = occurrence.toInstant().toString();
+			planned.push({
+				reminderId: item.id,
+				occurrenceAt,
+				runAt: runAt.toInstant(),
+				dedupeKey: `${item.id}:${occurrenceAt}`
+			});
+		}
+	}
+	return planned;
+}
+/** Records the delivery, then notifies. A second run of the same occurrence is a no-op in SQL. */
+async function deliverReminder(payload, effects) {
+	await effects.markSent(payload.reminderId, payload.occurrenceAt);
+	await effects.notify(payload);
+}
+//#endregion
+//#region src/blocks/reminders/reminders.ts
+/** Sends `notification` through `notifier` for a delivered reminder. */
+function notifyThrough(options) {
+	const { notifier, notification } = options;
+	if (notifier === void 0 || notification === void 0) return;
+	return (delivery) => notifier.send(notification, {
+		recipients: delivery.userId === void 0 ? [] : [delivery.userId],
+		tenant: delivery.organizationId,
+		key: `reminder:${delivery.reminderId}:${delivery.occurrenceAt}`,
+		...delivery.subjectType === void 0 || delivery.subjectId === void 0 ? {} : { subject: {
+			type: delivery.subjectType,
+			id: delivery.subjectId
+		} },
+		data: {
+			reminderId: delivery.reminderId,
+			occurrenceAt: delivery.occurrenceAt
+		}
+	});
+}
+/** The queue `reminders.job` handles. */
+const REMINDER_DELIVERY_QUEUE = "reminders.deliver";
+function deliveryOf(value) {
+	if (!isRecord(value)) throw new TypeError(`${REMINDER_DELIVERY_QUEUE} needs an object payload`);
+	const userId = optionalText(value["userId"]);
+	const subjectType = optionalText(value["subjectType"]);
+	const subjectId = optionalText(value["subjectId"]);
+	return {
+		reminderId: textOf(value["reminderId"]),
+		occurrenceAt: textOf(value["occurrenceAt"]),
+		organizationId: textOf(value["organizationId"]),
+		...userId === void 0 ? {} : { userId },
+		...subjectType === void 0 ? {} : { subjectType },
+		...subjectId === void 0 ? {} : { subjectId }
+	};
+}
+function createReminders(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "reminder fields");
+	const notifyDelivery = options.notifyDelivery ?? notifyThrough(options);
+	const audience = options.audience ?? options.authorization?.delivery?.audience ?? (options.authorization === void 0 ? void 0 : subjectReaders(options.transport, options.schema === void 0 ? {} : { schema: options.schema }));
+	/** Whether `audience` lets the reminder's user have it, or the policy's failure. */
+	const permitted = (delivery) => AsyncResult.from(async () => {
+		if (audience === void 0 || delivery.userId === void 0) return ok(true);
+		const subscriber = {
+			principal: delivery.userId,
+			kind: "user"
+		};
+		const checked = await allowedSubscribers(audience, {
+			type: "reminder.due",
+			tenant: delivery.organizationId,
+			actorId: null,
+			payload: delivery,
+			subject: delivery.subjectType === void 0 || delivery.subjectId === void 0 ? null : `subjects/${delivery.subjectType}/${delivery.subjectId}`
+		}, [subscriber]);
+		return checked.ok ? ok(checked.allowed.length > 0) : err(dbError("unexpected", `The reminder audience check failed: ${checked.cause instanceof Error ? checked.cause.message : String(checked.cause)}`, { hint: "REMINDER_AUDIENCE_FAILED" }));
+	});
+	const markSent = (reminderId, occurrenceAt) => call("mark_reminder_sent", {
+		reminder: reminderId,
+		occurrence_at: occurrenceAt
+	}, (value) => value === true);
+	const deliver = (delivery) => (notifyDelivery === void 0 ? AsyncResult.ok(false) : permitted(delivery)).andThen((allowed) => hooked.markSent(delivery.reminderId, delivery.occurrenceAt).andThen(async (sent) => {
+		if (sent && allowed && notifyDelivery !== void 0) {
+			const outcome = await notifyDelivery(delivery);
+			if (isRecord(outcome) && outcome["ok"] === false && isDbError(outcome["error"])) return err(outcome["error"]);
+		}
+		return ok(sent);
+	}));
+	const hooked = withBlockHooks({
+		save: (organizationId, subjectType, subjectId, offsetMinutes, values) => writeFields(fields, values, (checked) => call("save_reminder", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			offset_minutes: offsetMinutes ?? 0,
+			fields: checked
+		}, (value) => {
+			const row = recordOf(value, "save_reminder");
+			return {
+				id: textOf(row["id"]),
+				fields: rowFields(row["fields"])
+			};
+		})).andThen((saved) => readFields(fields, saved)),
+		list: (organizationId, subjectType, subjectId) => call("list_my_reminders", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId
+		}, (value) => recordsOf(value, "list_my_reminders").map((row) => ({
+			id: textOf(row["id"]),
+			method: textOf(row["method"]),
+			offsetMinutes: Number(row["offsetMinutes"])
+		}))),
+		remove: (reminderId) => call("delete_reminder", { reminder: reminderId }, (value) => value === true),
+		markSent,
+		deliver,
+		job: async (payload) => {
+			await hooked.deliver(deliveryOf(payload)).orThrow();
+		}
+	}, options.hooks, {
+		block: "reminders",
+		...options.logger ? { logger: options.logger } : {}
+	});
+	return hooked;
+}
+//#endregion
+//#region src/blocks/reminders/events.ts
+/** The `reminders` block's event types, for its manifest and `onBlockEvent`. */
+const remindersEvents = defineEvents({ "reminder.sent": event() });
+//#endregion
+//#region src/blocks/reminders/manifest.ts
+/** The `reminders` block's manifest (ADR 0029). */
+const remindersBlock = defineBlock({
+	name: "reminders",
+	sql: ["reminders"],
+	options: { reminders: remindersSqlOptions },
+	events: remindersEvents,
+	consumes: { notifier: "optional" },
+	create: createReminders,
+	category: "scheduling",
+	recipes: ["reminders-list"]
+});
+//#endregion
+export { REMINDER_DELIVERY_QUEUE, createReminders, deliverReminder, expandRule, planReminderDeliveries, remindersBlock, remindersEvents, weekdayName };

package/dist/blocks/reviews/index.d.ts

@@ -0,0 +1,148 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+//#region src/blocks/reviews/reviews.d.ts
+interface ReviewsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the review's extra columns
+   * (`blocks.reviews.options.extraColumns`), keyed by database name. It
+   * types and parses them on reads, and validates them on `submit`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Reviews<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+type ReviewStatus = "pending" | "published" | "rejected";
+/** A review. `F` types the extra columns the `fields` schema describes. */
+interface Review<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Missing on `list`, which hides who wrote each review; `mine` marks the caller's. */
+  readonly authorId?: string;
+  readonly authorName?: string;
+  /** Whether the caller wrote it. */
+  readonly mine: boolean;
+  /** From 1 to `blocks.reviews.options.scale` (default 5). */
+  readonly rating: number;
+  readonly title?: string;
+  readonly body?: string;
+  readonly status: ReviewStatus;
+  /** Whether the orders module shows a paid order for the product. */
+  readonly verified: boolean;
+  /** Why a moderator rejected it; the author sees it. */
+  readonly rejectionReason?: string;
+  /** The organization's public reply. */
+  readonly reply?: string;
+  readonly repliedAt?: Temporal.Instant;
+  readonly publishedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface ReviewInput<F extends object = Record<never, never>> {
+  readonly rating: number;
+  readonly body?: string;
+  readonly title?: string;
+  /** The name shown with the review. */
+  readonly authorName?: string;
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+interface ReviewListOptions {
+  readonly pageSize?: number;
+  /** Reviews published before this instant, for the next page. */
+  readonly before?: Temporal.Instant;
+  /** Only this rating. */
+  readonly rating?: number;
+  /** Only verified (`true`) or unverified (`false`) reviews. */
+  readonly verified?: boolean;
+}
+interface ReviewQueueOptions {
+  /** Default `pending`; `null` lists every status. */
+  readonly status?: ReviewStatus | null;
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly pageSize?: number;
+  /** Reviews written before this instant, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+/** One subject's published reviews, counted. */
+interface ReviewSummary {
+  readonly count: number;
+  /** The mean rating, rounded to two decimals. */
+  readonly average: number;
+  /** How many reviews gave each rating, keyed by rating. */
+  readonly histogram: Readonly<Record<number, number>>;
+}
+interface Reviews<F extends object = Record<never, never>> {
+  /**
+   * Writes the caller's review of a subject, or replaces it (one per user
+   * and subject). It waits for `publish` under pre-moderation.
+   */
+  submit(organizationId: string, subjectType: string, subjectId: string, input: ReviewInput<F>): AsyncResult<Review<F>>;
+  /** The caller's review of the subject in any status. */
+  mine(organizationId: string, subjectType: string, subjectId: string): AsyncResult<Review<F> | undefined>;
+  /** The subject's published reviews, newest first. Anonymous visitors can call it for a public storefront's products. */
+  list(organizationId: string, subjectType: string, subjectId: string, options?: ReviewListOptions): AsyncResult<readonly Review<F>[]>;
+  /** The rating aggregate of up to 200 subjects of one type, by subject id. Subjects without published reviews are left out. */
+  summary(organizationId: string, subjectType: string, subjectIds: readonly string[]): AsyncResult<Readonly<Record<string, ReviewSummary>>>;
+  /** Reviews for moderators, newest first; needs `reviews.manage`. */
+  queue(organizationId: string, options?: ReviewQueueOptions): AsyncResult<readonly Review<F>[]>;
+  /** Needs `reviews.manage`. */
+  publish(reviewId: string): AsyncResult<Review<F>>;
+  /** Needs `reviews.manage`. */
+  reject(reviewId: string, reason?: string): AsyncResult<Review<F>>;
+  /** Sets the organization's public reply; `null` removes it. Needs `reviews.manage`. */
+  reply(reviewId: string, reply: string | null): AsyncResult<Review<F>>;
+  /** The author or a moderator; `false` when the review is gone. */
+  remove(reviewId: string): AsyncResult<boolean>;
+}
+/** The `reviews` SQL module as typed calls. */
+export declare function createReviews<S extends StandardSchemaV1 | undefined = undefined>(options: ReviewsOptions<S>): Reviews<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/reviews/events.d.ts
+/** `review.*`: which review changed, its subject and its state after the change. */
+interface ReviewEventData {
+  readonly organizationId: string;
+  /** The review. */
+  readonly id: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly authorId: string | null;
+  readonly rating: number;
+  readonly status: "pending" | "published" | "rejected";
+  /** Whether the orders module shows a paid order for the product. */
+  readonly verified: boolean;
+}
+/** The events of the `reviews` block: type to data. */
+type ReviewsEvents = {
+  readonly "review.submitted": ReviewEventData;
+  readonly "review.published": ReviewEventData;
+  readonly "review.rejected": ReviewEventData;
+  readonly "review.replied": ReviewEventData;
+  readonly "review.deleted": ReviewEventData;
+};
+/** The `reviews` block's event types, for its manifest and `onBlockEvent`. */
+export declare const reviewsEvents: Events<ReviewsEvents>;
+//#endregion
+//#region src/blocks/reviews/manifest.d.ts
+/** The `reviews` block's manifest (ADR 0029). */
+export declare const reviewsBlock: BlockOf<"reviews", typeof createReviews, ReviewsEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Review, type ReviewEventData, type ReviewInput, type ReviewListOptions, type ReviewQueueOptions, type ReviewStatus, type ReviewSummary, type Reviews, type ReviewsEvents, type ReviewsOptions, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/reviews/index.js

@@ -0,0 +1,139 @@
+import { t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as reviewsSqlOptions } from "../../options-CGjGE8xS.js";
+//#region src/blocks/reviews/reviews.ts
+const STATUSES = [
+	"pending",
+	"published",
+	"rejected"
+];
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+function reviewOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		mine: row["mine"] === true,
+		rating: typeof row["rating"] === "number" ? row["rating"] : 0,
+		status: enumOrThrow(row["status"], STATUSES, "review status"),
+		verified: row["verified"] === true,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("authorId", optionalText(row["authorId"])),
+		...optional("authorName", optionalText(row["authorName"])),
+		...optional("title", optionalText(row["title"])),
+		...optional("body", optionalText(row["body"])),
+		...optional("rejectionReason", optionalText(row["rejectionReason"])),
+		...optional("reply", optionalText(row["reply"])),
+		...optional("repliedAt", optionalInstant(row["repliedAt"])),
+		...optional("publishedAt", optionalInstant(row["publishedAt"])),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+function summaryOf(value) {
+	const out = {};
+	for (const [id, entry] of Object.entries(recordOf(value, "review_summary"))) {
+		const row = isRecord(entry) ? entry : {};
+		const histogram = {};
+		for (const [rating, count] of Object.entries(isRecord(row["histogram"]) ? row["histogram"] : {})) if (typeof count === "number") histogram[Number(rating)] = count;
+		out[id] = {
+			count: typeof row["count"] === "number" ? row["count"] : 0,
+			average: Number(row["average"] ?? 0),
+			histogram
+		};
+	}
+	return out;
+}
+/** The `reviews` SQL module as typed calls. */
+function createReviews(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "review fields");
+	const one = (fn) => (value) => reviewOf(value, fn);
+	const many = (fn) => (value) => recordsOf(value, fn).map((row) => reviewOf(row, fn));
+	return withBlockHooks({
+		submit: (organizationId, subjectType, subjectId, input) => fields.args(input.fields).andThen((checked) => call("submit_review", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			rating: input.rating,
+			body: input.body ?? null,
+			title: input.title ?? null,
+			author_name: input.authorName ?? null,
+			...checked === void 0 ? {} : { fields: checked }
+		}, one("submit_review")).andThen(fields.row)),
+		mine: (organizationId, subjectType, subjectId) => call("my_review", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId
+		}, (value) => value === null || value === void 0 ? void 0 : reviewOf(value, "my_review")).andThen((review) => review === void 0 ? AsyncResult.ok(void 0) : fields.row(review)),
+		list: (organizationId, subjectType, subjectId, list = {}) => call("list_reviews", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			page_size: list.pageSize ?? null,
+			before: instantArg(list.before) ?? null,
+			rating: list.rating ?? null,
+			verified: list.verified ?? null
+		}, many("list_reviews")).andThen(fields.rows),
+		summary: (organizationId, subjectType, subjectIds) => call("review_summary", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_ids: subjectIds
+		}, summaryOf),
+		queue: (organizationId, queue = {}) => call("review_queue", {
+			tenant: organizationId,
+			status: queue.status === void 0 ? "pending" : queue.status,
+			page_size: queue.pageSize ?? null,
+			before: instantArg(queue.before) ?? null,
+			subject_type: queue.subjectType ?? null,
+			subject_id: queue.subjectId ?? null
+		}, many("review_queue")).andThen(fields.rows),
+		publish: (reviewId) => call("publish_review", { review_id: reviewId }, one("publish_review")).andThen(fields.row),
+		reject: (reviewId, reason) => call("reject_review", {
+			review_id: reviewId,
+			reason: reason ?? null
+		}, one("reject_review")).andThen(fields.row),
+		reply: (reviewId, reply) => call("reply_to_review", {
+			review_id: reviewId,
+			reply
+		}, one("reply_to_review")).andThen(fields.row),
+		remove: (reviewId) => call("delete_review", { review_id: reviewId }, (value) => value === true)
+	}, options.hooks, {
+		block: "reviews",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/reviews/events.ts
+/** The `reviews` block's event types, for its manifest and `onBlockEvent`. */
+const reviewsEvents = defineEvents({
+	"review.submitted": event(),
+	"review.published": event(),
+	"review.rejected": event(),
+	"review.replied": event(),
+	"review.deleted": event()
+});
+//#endregion
+//#region src/blocks/reviews/manifest.ts
+/** The `reviews` block's manifest (ADR 0029). */
+const reviewsBlock = defineBlock({
+	name: "reviews",
+	sql: ["reviews"],
+	options: { reviews: reviewsSqlOptions },
+	events: reviewsEvents,
+	create: createReviews,
+	category: "commerce"
+});
+//#endregion
+export { createReviews, dbTransport, extendBlock, reviewsBlock, reviewsEvents, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/rules/index.d.ts

@@ -0,0 +1,103 @@
+import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { _ as FilterRule, f as FilterNode, h as FilterQuery, i as FilterCombinator, m as FilterOperatorSpec } from "../../filter-query-BKmRYrTE.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { o as ApprovalRequestInput } from "../../approvals-a2KmioBh.js";
+import { A as RuleField, C as createRuleDispatcher, D as ruleOf, E as evaluateRule, F as ruleFilterFieldInfo, I as ruleFilterFields, M as RuleFieldDefinition, N as checkRuleConditions, O as ruleRecordFields, P as defineRuleFields, S as RulesOptions, T as createRulesAdmin, _ as RuleSubject, a as createRuleBuilderController, b as RulesAdmin, c as RuleActionCall, d as RuleDispatcher, f as RuleDispatcherOptions, g as RuleMatch, h as RuleListOptions, i as RuleBuilderSnapshot, j as RuleFieldCatalog, k as RULE_LIMITS, l as RuleActionHandler, m as RuleInput, n as RuleBuilderController, o as Rule, p as RuleEvaluationEntry, r as RuleBuilderControllerOptions, s as RuleAction, t as RuleBuilderActions, u as RuleActionOutcome, v as RuleVersion, w as createRules, x as RulesAdminOptions, y as Rules } from "../../client-Tc47rlSe.js";
+//#region src/blocks/rules/tree.d.ts
+/** The operators a field allows, in the order the editor lists them. */
+export declare function ruleOperators(field: RuleField): readonly FilterOperatorSpec[];
+/** An empty `and` group, the tree a new rule starts with. */
+export declare const emptyConditions: (id?: string) => FilterQuery;
+/** The node with `id`, or `undefined`. */
+export declare function findNode(tree: FilterNode, id: string): FilterNode | undefined;
+/** The group that holds `id`, or `undefined` for the root and unknown ids. */
+export declare function parentOf(tree: FilterQuery, id: string): FilterQuery | undefined;
+/** Whether `id` is `ancestor` or sits anywhere under it. */
+export declare function contains(ancestor: FilterNode, id: string): boolean;
+/** Replaces the node with `id` by what `change` returns. */
+export declare function updateNode(tree: FilterQuery, id: string, change: (node: FilterNode) => FilterNode): FilterQuery;
+/** Drops the node with `id` and everything under it; the root stays. */
+export declare function removeNode(tree: FilterQuery, id: string): FilterQuery;
+/**
+ * Adds `node` to the group `parent` at `index` (the end by default).
+ * Unchanged when `parent` isn't a group in the tree.
+ */
+export declare function insertNode(tree: FilterQuery, parent: string, node: FilterNode, index?: number): FilterQuery;
+/**
+ * Moves the node with `id` into the group `parent`, where it ends up at
+ * `index` (as `arrayMove` counts it). Unchanged for the root, an unknown
+ * node or group, or a move into the node itself.
+ */
+export declare function moveNode(tree: FilterQuery, id: string, parent: string, index: number): FilterQuery;
+/** Changes a group's `and` or `or`. */
+export declare function setCombinator(tree: FilterQuery, id: string, combinator: FilterCombinator): FilterQuery;
+/**
+ * Points a rule at another field. A field of the same type keeps the
+ * operator it allows, and its value; another type starts at the field's
+ * first operator without a value.
+ */
+export declare function setRuleField(rule: FilterRule, field: RuleField, previous: RuleField | undefined): FilterRule;
+/**
+ * Changes a rule's operator. The value stays when the new operator takes
+ * the same kind of value (one, many or a range), and is dropped otherwise.
+ */
+export declare function setRuleOperator(rule: FilterRule, operator: string, field: RuleField | undefined): FilterRule;
+//#endregion
+//#region src/blocks/rules/actions.d.ts
+/** The context `dispatch` passes when rules start approvals or other subject work. */
+interface RuleSubjectContext {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Passed on to the approval request, such as the expense amount. */
+  readonly payload?: Readonly<Record<string, unknown>>;
+}
+/** The part of the approvals client the handler calls. */
+interface RuleApprovals {
+  request(input: ApprovalRequestInput): AsyncResult<unknown>;
+}
+/**
+ * The `approvals.request` handler: starts an approval of the subject for the
+ * action in the rule's `config.action`, such as `{ kind: "approvals.request",
+ * config: { action: "manager_review" } }`.
+ */
+export declare function approvalsAction(approvals: RuleApprovals): RuleActionHandler<RuleSubjectContext>;
+//#endregion
+//#region src/blocks/rules/events.d.ts
+/** `rule.saved`, `rule.enabled`, `rule.disabled` and `rule.removed`. */
+interface RuleEventData {
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly name: string;
+  readonly subjectType: string;
+  readonly trigger: string;
+  readonly version: number;
+}
+/** `rule.matched`: a live evaluation matched a subject. */
+interface RuleMatchedEventData {
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly version: number;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly trigger: string;
+}
+/** The events of the `rules` block: type to data. */
+type RulesEvents = {
+  readonly "rule.saved": RuleEventData;
+  readonly "rule.enabled": RuleEventData;
+  readonly "rule.disabled": RuleEventData;
+  readonly "rule.removed": RuleEventData;
+  readonly "rule.matched": RuleMatchedEventData;
+};
+/** The `rules` block's event types, for its manifest and `onBlockEvent`. */
+export declare const rulesEvents: Events<RulesEvents>;
+//#endregion
+//#region src/blocks/rules/manifest.d.ts
+/** The `rules` block's manifest (ADR 0029). */
+export declare const rulesBlock: BlockOf<"rules", typeof createRules, RulesEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, RULE_LIMITS, type RpcClient, type Rule, type RuleAction, type RuleActionCall, type RuleActionHandler, type RuleActionOutcome, type RuleApprovals, type RuleBuilderActions, type RuleBuilderController, type RuleBuilderControllerOptions, type RuleBuilderSnapshot, type RuleDispatcher, type RuleDispatcherOptions, type RuleEvaluationEntry, type RuleEventData, type RuleField, type RuleFieldCatalog, type RuleFieldDefinition, type RuleInput, type RuleListOptions, type RuleMatch, type RuleMatchedEventData, type RuleSubject, type RuleSubjectContext, type RuleVersion, type Rules, type RulesAdmin, type RulesAdminOptions, type RulesEvents, type RulesOptions, checkRuleConditions, createRuleBuilderController, createRuleDispatcher, createRules, createRulesAdmin, dbTransport, defineRuleFields, evaluateRule, extendBlock, rpcTransport, ruleFilterFieldInfo, ruleFilterFields, ruleOf, ruleRecordFields, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/rules/index.js

@@ -0,0 +1,54 @@
+import { n as dbError } from "../../errors-8i6tSICm.js";
+import { r as err } from "../../result-BlgnMB0H.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { _ as ruleFilterFieldInfo, a as insertNode, c as removeNode, d as setRuleField, f as setRuleOperator, g as defineRuleFields, h as checkRuleConditions, i as findNode, l as ruleOperators, m as RULE_LIMITS, n as contains, o as moveNode, p as updateNode, r as emptyConditions, s as parentOf, t as createRuleBuilderController, u as setCombinator, v as ruleFilterFields } from "../../client-b2_GjzzD.js";
+import { a as ruleOf, i as evaluateRule, n as createRules, o as ruleRecordFields, r as createRulesAdmin, t as createRuleDispatcher } from "../../rules-B0-3Iosu.js";
+import { t as rulesSqlOptions } from "../../options-ChD15QxJ.js";
+//#region src/blocks/rules/actions.ts
+/**
+* The `approvals.request` handler: starts an approval of the subject for the
+* action in the rule's `config.action`, such as `{ kind: "approvals.request",
+* config: { action: "manager_review" } }`.
+*/
+function approvalsAction(approvals) {
+	return ({ action, rule, context }) => {
+		const name = action.config?.["action"];
+		if (typeof name !== "string" || name === "") return err(dbError("invalid_request", `The rule "${rule.name}" has an approvals.request action without config.action`, { hint: "RULE_ACTION_INVALID" }));
+		const reason = action.config?.["reason"];
+		return approvals.request({
+			organizationId: context.organizationId,
+			subjectType: context.subjectType,
+			subjectId: context.subjectId,
+			action: name,
+			reason: typeof reason === "string" ? reason : `Rule: ${rule.name}`,
+			...context.payload === void 0 ? {} : { payload: context.payload }
+		});
+	};
+}
+//#endregion
+//#region src/blocks/rules/events.ts
+/** The `rules` block's event types, for its manifest and `onBlockEvent`. */
+const rulesEvents = defineEvents({
+	"rule.saved": event(),
+	"rule.enabled": event(),
+	"rule.disabled": event(),
+	"rule.removed": event(),
+	"rule.matched": event()
+});
+//#endregion
+//#region src/blocks/rules/manifest.ts
+/** The `rules` block's manifest (ADR 0029). */
+const rulesBlock = defineBlock({
+	name: "rules",
+	sql: ["rules"],
+	options: { rules: rulesSqlOptions },
+	events: rulesEvents,
+	create: createRules,
+	category: "automation",
+	recipes: ["rule-builder"]
+});
+//#endregion
+export { RULE_LIMITS, approvalsAction, checkRuleConditions, contains, createRuleBuilderController, createRuleDispatcher, createRules, createRulesAdmin, dbTransport, defineRuleFields, emptyConditions, evaluateRule, extendBlock, findNode, insertNode, moveNode, parentOf, removeNode, rpcTransport, ruleFilterFieldInfo, ruleFilterFields, ruleOf, ruleOperators, ruleRecordFields, rulesBlock, rulesEvents, setCombinator, setRuleField, setRuleOperator, sqlTransport, updateNode, withBlockHooks, wrapTransport };

package/dist/blocks/rules/react/index.d.ts

@@ -0,0 +1,34 @@
+import { d as FilterLimits, h as FilterQuery } from "../../../filter-query-BKmRYrTE.js";
+import { i as RuleBuilderSnapshot, t as RuleBuilderActions, y as Rules } from "../../../client-Tc47rlSe.js";
+//#region src/blocks/rules/react/index.d.ts
+export interface UseRuleBuilderOptions {
+  readonly organizationId: string;
+  /** The rule to edit; `null` edits a new one. */
+  readonly rule: string | null;
+  /** The record type whose fields the rules test. */
+  readonly subjectType: string;
+  /** A new rule's trigger, such as `expense.submitted`. */
+  readonly trigger?: string;
+  /** The tree a new rule starts with. Read once, when the editor starts. */
+  readonly initial?: FilterQuery;
+  /** Node ids the editor may not change. Read once, when the editor starts. */
+  readonly locked?: readonly string[];
+  readonly limits?: FilterLimits;
+  /** The schema the calls go to (default `better_supabase`). */
+  readonly schema?: string;
+}
+export interface RuleBuilderState extends RuleBuilderSnapshot, RuleBuilderActions {
+  /** The rules client for the signed-in user, for lists and toggles. */
+  readonly rules: Rules;
+}
+/**
+ * The editor state of one rule: its fields, its condition tree with the
+ * edits to it, validation, dirty state and save.
+ *
+ * ```tsx
+ * const builder = useRuleBuilder({ organizationId, rule: null, subjectType: "expense" });
+ * builder.addRule(undefined, "amount");
+ * ```
+ */
+export declare function useRuleBuilder(options: UseRuleBuilderOptions): RuleBuilderState;
+//#endregion