better-supabase 0.7.1 → 0.9.0

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

@@ -0,0 +1,177 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { et as SaasSubjectEventData, 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 { t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { i as RowFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { g as JobHandler } from "../../types-CdP0z5tS.js";
+import { g as SubscriberPolicy, i as AuthorizationHooks } from "../../authorization-hooks-DkmrnDX7.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { n as Notifier } from "../../ports-Ca63W4cW.js";
+//#region src/blocks/reminders/rrule.d.ts
+interface ExpandInput {
+  readonly dtstart: Temporal.ZonedDateTime;
+  /** An `RRULE` value, with or without the `RRULE:` prefix. */
+  readonly rrule?: string;
+  /** CentraKit's column shape, used when `ruleFormat` is `columns`. */
+  readonly columns?: {
+    readonly frequency: "daily" | "weekly" | "monthly" | "yearly";
+    readonly interval?: number;
+    readonly weekDays?: readonly number[];
+    readonly monthDay?: number;
+    readonly monthWeekday?: number;
+    readonly monthOrdinal?: number;
+    readonly count?: number;
+    readonly until?: Temporal.Instant;
+  };
+  /** Stops after this many occurrences. COUNT still wins when it is smaller. */
+  readonly limit?: number;
+  /**
+   * Returns only the occurrences that start in `[from, until)`. COUNT still
+   * counts from `dtstart`; without COUNT the expansion skips ahead to the
+   * window, so a long-running series stays cheap. `limit` then caps the
+   * occurrences in the window (default 1000).
+   */
+  readonly window?: {
+    readonly from: Temporal.Instant;
+    readonly until: Temporal.Instant;
+  };
+}
+/** The occurrences of a rule, in order, starting at `dtstart` when it matches. */
+export declare function expandRule(input: ExpandInput): Temporal.ZonedDateTime[];
+/** A weekday name for a column-format rule, 1 (Monday) through 7 (Sunday). */
+export declare function weekdayName(day: number): string;
+//#endregion
+//#region src/blocks/reminders/schedule.d.ts
+interface ReminderPlanInput {
+  readonly id: string;
+  readonly dtstart: Temporal.ZonedDateTime;
+  readonly rrule?: string;
+  readonly columns?: ExpandInput["columns"];
+  readonly offsetMinutes: number;
+}
+interface PlannedDelivery {
+  readonly reminderId: string;
+  readonly occurrenceAt: string;
+  readonly runAt: Temporal.Instant;
+  /** One job per reminder and occurrence. Pass this to `enqueueOnce`. */
+  readonly dedupeKey: string;
+}
+interface DeliveryPayload {
+  readonly reminderId: string;
+  readonly occurrenceAt: string;
+  readonly organizationId: string;
+  /** Who set the reminder; `createBlocks` notifies them. */
+  readonly userId?: string;
+  /** The reminded subject, from `list_reminder_schedule`; its watchers are notified too. */
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+}
+/**
+ * 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`.
+ */
+export declare function planReminderDeliveries(items: readonly ReminderPlanInput[], window: {
+  readonly from: Temporal.ZonedDateTime;
+  readonly until: Temporal.ZonedDateTime;
+}): readonly PlannedDelivery[];
+/** Records the delivery, then notifies. A second run of the same occurrence is a no-op in SQL. */
+export declare function deliverReminder(payload: DeliveryPayload, effects: {
+  readonly markSent: (reminderId: string, occurrenceAt: string) => Promise<void>;
+  readonly notify: (payload: DeliveryPayload) => Promise<void>;
+}): Promise<void>;
+//#endregion
+//#region src/blocks/reminders/reminders.d.ts
+/** The queue `reminders.job` handles. */
+export declare const REMINDER_DELIVERY_QUEUE = "reminders.deliver";
+interface RemindersOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * Runs after `deliver` records an occurrence for the first time. Defaults
+   * to sending `notification` through `notifier`.
+   */
+  readonly notifyDelivery?: (delivery: DeliveryPayload) => unknown;
+  /** The `notifier` port: the `notifications` block, from `createBlocks`. */
+  readonly notifier?: Notifier;
+  /**
+   * The notification type `notifier` sends for a delivered reminder, to the
+   * user who set it and the reminded subject's watchers. Its data is
+   * `{ reminderId, occurrenceAt }`.
+   */
+  readonly notification?: string;
+  /**
+   * Checks the reminder's user before `notifyDelivery` runs; a user it
+   * leaves out gets nothing, and a throw fails the delivery so the job
+   * retries. Defaults to `authorization.delivery.audience`; with
+   * `authorization` but no such policy, to `subjectReaders(transport)`, so
+   * a user who lost access to the subject stops getting its reminders.
+   */
+  readonly audience?: SubscriberPolicy;
+  /** `server.authorization`, for its `delivery.audience` policy. */
+  readonly authorization?: Pick<AuthorizationHooks, "delivery">;
+  /**
+   * A Standard Schema for the extra columns of the reminders table
+   * (`blocks.reminders.options.extraColumns`): writes are validated, reads
+   * parsed.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Reminders<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A saved reminder: its id and the app's extra columns. */
+interface SavedReminder<F extends object = Record<never, never>> {
+  readonly id: string;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+/** One of the caller's reminders, from `list`. */
+interface ReminderEntry {
+  readonly id: string;
+  readonly method: string;
+  /** Minutes before the occurrence; negative fires after it. */
+  readonly offsetMinutes: number;
+}
+interface Reminders<F extends object = Record<never, never>> {
+  /** Sets a reminder on a subject; `fields` fills the app's extra columns. */
+  save(organizationId: string, subjectType: string, subjectId: string, offsetMinutes?: number, fields?: Partial<F> & Readonly<Record<string, unknown>>): AsyncResult<SavedReminder<F>>;
+  /** The caller's reminders on a subject, the earliest before the occurrence first. */
+  list(organizationId: string, subjectType: string, subjectId: string): AsyncResult<readonly ReminderEntry[]>;
+  /** Removes one of the caller's reminders; `false` when there was none. */
+  remove(reminderId: string): AsyncResult<boolean>;
+  /**
+   * Service role. Records one delivery and the reminder.sent event.
+   * Resolves to `false` when the occurrence was already delivered.
+   */
+  markSent(reminderId: string, occurrenceAt: string): AsyncResult<boolean>;
+  /**
+   * Checks `audience`, then `markSent`, then `notifyDelivery` when this run
+   * recorded the occurrence and the audience kept the user.
+   */
+  deliver(delivery: DeliveryPayload): AsyncResult<boolean>;
+  /** The handler for the `reminders.deliver` queue. */
+  readonly job: JobHandler<unknown>;
+}
+export declare function createReminders<S extends StandardSchemaV1 | undefined = undefined>(options: RemindersOptions<S>): Reminders<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/reminders/events.d.ts
+/** The events of the `reminders` block: type to data. */
+type RemindersEvents = {
+  readonly "reminder.sent": SaasSubjectEventData;
+};
+/** The `reminders` block's event types, for its manifest and `onBlockEvent`. */
+export declare const remindersEvents: Events<RemindersEvents>;
+//#endregion
+//#region src/blocks/reminders/manifest.d.ts
+/** The `reminders` block's manifest (ADR 0029). */
+export declare const remindersBlock: BlockOf<"reminders", typeof createReminders, RemindersEvents, {
+  readonly notifier: "optional";
+}>;
+//#endregion
+export type { DeliveryPayload, ExpandInput, PlannedDelivery, ReminderEntry, ReminderPlanInput, Reminders, RemindersEvents, RemindersOptions, SavedReminder };

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 };