better-supabase 0.12.0 → 0.13.0

package/dist/client-DD02cst6.d.ts

@@ -0,0 +1,245 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-mijqfoJN.js";
+import { t as StandardSchemaV1 } from "./standard-16AIDny5.js";
+import { r as FieldsOf } from "./block-fields-DnXkMney.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-DyA5BAW4.js";
+import { n as BlockHooks } from "./block-hooks-BadAniNI.js";
+import { g as JobHandler } from "./types-CB5MvzuE.js";
+import { n as Controller } from "./controller-lWRcKqCl.js";
+import { t as VisibleRange } from "./range-p5V4rBhZ.js";
+//#region src/blocks/bookings/bookings.d.ts
+interface BookingsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the booking columns the app adds
+   * (`blocks.bookings.options.extraColumns`), keyed by column name. The
+   * customer object of `hold` and `public.hold` carries them; the schema
+   * validates them there, which returns a `validation` error for a bad value,
+   * and types and parses them on every booking read.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Bookings<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** The queue each hold enqueues a job on, to expire it when its time is up. */
+declare const BOOKING_EXPIRE_QUEUE = "bookings.expire-holds";
+/**
+ * A duration as a `Temporal.Duration` or an ISO 8601 / Postgres interval
+ * string.
+ */
+type BookingDuration = Temporal.Duration | string;
+interface BookingRange {
+  readonly from: Temporal.Instant;
+  readonly until: Temporal.Instant;
+}
+interface BookingResourceInput {
+  readonly id?: string;
+  readonly name?: string;
+  /**
+   * What the resource is, matched against a service's `resourceKinds`. Default
+   * `staff`.
+   */
+  readonly kind?: string;
+  /** How many bookings can overlap: seats in a class, desks in a room. Default 1. */
+  readonly capacity?: number;
+  /** The IANA zone its weekly hours are in. Default `UTC`. */
+  readonly tz?: string;
+  /**
+   * The calendar confirmed bookings are copied into, when the calendar block is
+   * installed.
+   */
+  readonly calendarId?: string | null;
+  readonly active?: boolean;
+}
+/**
+ * Weekly opening hours: `weekday` 1 is Monday, times are `HH:MM` in the
+ * resource's zone.
+ */
+interface WeeklyHours {
+  readonly weekday: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+  readonly start: string;
+  readonly end: string;
+}
+interface BookingExceptionInput {
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant;
+  /**
+   * `true` opens the resource outside its hours. Default `false`, which closes
+   * it.
+   */
+  readonly available?: boolean;
+  readonly reason?: string;
+}
+interface BookingServiceInput {
+  readonly id?: string;
+  readonly name?: string;
+  readonly duration?: BookingDuration;
+  readonly bufferBefore?: BookingDuration;
+  readonly bufferAfter?: BookingDuration;
+  /** The resource kinds that can serve it; empty means every resource. */
+  readonly resourceKinds?: readonly string[];
+  /** The distance between slot starts. Default the duration. */
+  readonly step?: BookingDuration | null;
+  /** How far ahead a slot must start. */
+  readonly minNotice?: BookingDuration;
+  /** How long a hold keeps the slot. Default 10 minutes. */
+  readonly holdFor?: BookingDuration;
+  /** Minutes before the start that reminders go out. Default one day. */
+  readonly reminderOffsets?: readonly number[];
+  readonly active?: boolean;
+}
+interface BookingSlot {
+  readonly resourceId: string;
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant;
+  /** The start as wall-clock time in the zone asked for, else the resource's. */
+  readonly localStart: Temporal.PlainDateTime;
+  /** Free seats at this time. */
+  readonly seats: number;
+}
+interface BookingCustomer {
+  readonly name?: string;
+  readonly email?: string;
+  /** Only managers can book for another user. */
+  readonly userId?: string;
+  readonly notes?: string;
+}
+type BookingStatus = "hold" | "confirmed" | "cancelled";
+interface Booking {
+  readonly id: string;
+  readonly resourceId: string;
+  readonly serviceId: string;
+  readonly seat: number;
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant;
+  readonly status: BookingStatus;
+  readonly holdExpiresAt?: Temporal.Instant;
+  readonly customerName?: string;
+  readonly customerEmail?: string;
+  readonly customerUserId?: string;
+  readonly notes?: string;
+  readonly createdAt?: Temporal.Instant;
+  readonly cancelledAt?: Temporal.Instant;
+  readonly cancelReason?: string;
+}
+/**
+ * A new booking with the token that confirms or cancels it without signing in.
+ * Shown once.
+ */
+interface PlacedBooking extends Booking {
+  readonly accessToken: string;
+}
+interface PublicBookingService {
+  readonly id: string;
+  readonly name: string;
+  /** The duration as Postgres prints an interval, such as `00:30:00`. */
+  readonly duration: string;
+  readonly resources: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly tz: string;
+  }[];
+}
+/** The payload a hold enqueues on `bookings.expire-holds`. */
+interface BookingExpirePayload {
+  readonly bookingId?: string;
+}
+/** `F` is the extra booking fields `options.fields` describes. */
+interface Bookings<F extends object = Record<never, never>> {
+  saveResource(organizationId: string, input: BookingResourceInput): AsyncResult<{
+    readonly id: string;
+  }>;
+  /** Replaces a resource's weekly hours. Resolves to the number of rows. */
+  setAvailability(resourceId: string, hours: readonly WeeklyHours[]): AsyncResult<number>;
+  addException(resourceId: string, exception: BookingExceptionInput): AsyncResult<{
+    readonly id: string;
+  }>;
+  deleteException(id: string): AsyncResult<boolean>;
+  saveService(organizationId: string, input: BookingServiceInput): AsyncResult<{
+    readonly id: string;
+  }>;
+  /** The open slots of a service, at most 62 days at a time. */
+  availableSlots(serviceId: string, range: BookingRange, options?: {
+    readonly tz?: string;
+    readonly resourceId?: string;
+  }): AsyncResult<BookingSlot[]>;
+  /** Holds a slot for the service's `holdFor`, or books it with `confirm`. */
+  hold(serviceId: string, resourceId: string, startsAt: Temporal.Instant, customer?: BookingCustomer & Partial<F>, options?: {
+    readonly confirm?: boolean;
+  }): AsyncResult<PlacedBooking & F>;
+  confirm(bookingId: string): AsyncResult<Booking & F>;
+  cancel(bookingId: string, reason?: string): AsyncResult<Booking & F>;
+  /** The bookings that overlap the range, as the caller's policies allow. */
+  list(organizationId: string, range: BookingRange, options?: {
+    readonly resourceId?: string;
+  }): AsyncResult<(Booking & F)[]>;
+  /** Cancels every hold whose time is up. Service only. */
+  expireHolds(): AsyncResult<number>;
+  /** The handler for the `bookings.expire-holds` queue. */
+  readonly job: JobHandler<unknown>;
+  /**
+   * The public side, through a share link to a service (`subjectType:
+   * "booking_service"`).
+   */
+  readonly public: {
+    service(token: string): AsyncResult<PublicBookingService>;
+    slots(token: string, range: BookingRange, options?: {
+      readonly tz?: string;
+    }): AsyncResult<BookingSlot[]>;
+    /** Holds a slot for a guest, who must give a name and an email. */
+    hold(token: string, resourceId: string, startsAt: Temporal.Instant, customer: BookingCustomer & Partial<F> & {
+      readonly name: string;
+      readonly email: string;
+    }): AsyncResult<PlacedBooking & F>;
+    confirm(bookingId: string, accessToken: string): AsyncResult<Booking & F>;
+    cancel(bookingId: string, accessToken: string): AsyncResult<Booking & F>;
+  };
+}
+/** A booking row as `hold_booking`, `list_bookings` and the others return it. */
+declare function bookingOf(value: unknown): Booking;
+declare function createBookings<S extends StandardSchemaV1 | undefined = undefined>(options: BookingsOptions<S>): Bookings<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/bookings/client.d.ts
+interface AvailableSlotsOptions {
+  readonly client: Pick<Bookings, "availableSlots" | "hold"> & {
+    readonly public: Pick<Bookings["public"], "slots" | "hold">;
+  };
+  readonly serviceId: string;
+  /** The visible range; `setRange` changes it. */
+  readonly range: VisibleRange;
+  /** The zone slot times are shown in. Default each resource's. */
+  readonly tz?: string;
+  readonly resourceId?: string;
+  /** A share-link token: loads and holds slots as a guest. */
+  readonly token?: string;
+}
+interface AvailableSlotsSnapshot {
+  /** `undefined` until the first load. */
+  readonly slots: readonly BookingSlot[] | undefined;
+  /** The slots by local date (`YYYY-MM-DD`), for a day-by-day picker. */
+  readonly days: ReadonlyMap<string, readonly BookingSlot[]>;
+  readonly error: DbError | undefined;
+  /** True until the slots of the current range arrive. */
+  readonly loading: boolean;
+}
+interface AvailableSlotsActions {
+  readonly refresh: () => Promise<void>;
+  /**
+   * Holds a slot, then loads the range again. With a token, `customer` needs a
+   * name and an email.
+   */
+  readonly hold: (slot: BookingSlot, customer?: BookingCustomer) => Promise<PlacedBooking | undefined>;
+  /** Shows another range; the current slots stay until its slots arrive. */
+  readonly setRange: (range: VisibleRange) => void;
+}
+type AvailableSlotsController = Controller<AvailableSlotsSnapshot, AvailableSlotsActions>;
+/**
+ * The open slots of a service in the visible range, for a headless date and
+ * time picker.
+ */
+declare function createAvailableSlotsController(options: AvailableSlotsOptions): AvailableSlotsController;
+//#endregion
+export { createBookings as C, bookingOf as S, Bookings as _, createAvailableSlotsController as a, PublicBookingService as b, BookingCustomer as c, BookingExpirePayload as d, BookingRange as f, BookingStatus as g, BookingSlot as h, AvailableSlotsSnapshot as i, BookingDuration as l, BookingServiceInput as m, AvailableSlotsController as n, BOOKING_EXPIRE_QUEUE as o, BookingResourceInput as p, AvailableSlotsOptions as r, Booking as s, AvailableSlotsActions as t, BookingExceptionInput as u, BookingsOptions as v, WeeklyHours as x, PlacedBooking as y };

package/dist/client-DD3EcytK.js

@@ -0,0 +1,65 @@
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { n as watchRun, t as firstError } from "./run-watch-B-LoK5m1.js";
+//#region src/blocks/workflow-builder/client.ts
+/** The definitions the signed-in user may read and the step library. */
+function createWorkflowBuilderController(options) {
+	const tenant = options.tenant ?? null;
+	return defineController({
+		definitions: void 0,
+		steps: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const [listed, library] = await Promise.all([options.client.definitions.list(tenant ?? void 0), options.client.steps.list()]);
+			if (run !== state.run()) return;
+			state.set({
+				...listed.ok ? { definitions: listed.data } : {},
+				...library.ok ? { steps: library.data } : {},
+				error: firstError(listed, library)
+			});
+		};
+		return {
+			actions: { refresh },
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+const NO_NODES = {};
+/**
+* A run and the status of each of its nodes, loaded again on each message on
+* `workflow-run:<id>` (run status changes and node records).
+*/
+function createWorkflowCanvasRunController(options) {
+	const { client } = options;
+	const run = options.run ?? "";
+	return defineController({
+		run: void 0,
+		nodes: NO_NODES,
+		error: void 0,
+		status: "closed"
+	}, (state) => {
+		const watch = watchRun({
+			...options,
+			load: async () => {
+				const [found, listed] = await Promise.all([client.runs.get(run), client.nodeRuns.list(run)]);
+				return {
+					id: found.ok ? found.data?.id ?? null : null,
+					patch: {
+						...found.ok ? { run: found.data } : {},
+						...listed.ok ? { nodes: Object.fromEntries(listed.data.map((node) => [node.node, node])) } : {},
+						error: firstError(found, listed)
+					}
+				};
+			}
+		}, state);
+		return {
+			actions: { refresh: watch.refresh },
+			start: watch.start
+		};
+	});
+}
+//#endregion
+export { createWorkflowCanvasRunController as n, createWorkflowBuilderController as t };

package/dist/client-DEE57s9m.d.ts

@@ -0,0 +1,132 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, b as DbError, t as AsyncResult } from "./result-mijqfoJN.js";
+import { t as StandardSchemaV1 } from "./standard-16AIDny5.js";
+import { r as FieldsOf } from "./block-fields-DnXkMney.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as BlockTransport } from "./block-transport-DBPhgF3W.js";
+import { r as BlockTemporalOptions } from "./block-helpers-DyA5BAW4.js";
+import { n as BlockHooks } from "./block-hooks-BadAniNI.js";
+import { p as SubscriptionStatus } from "./topic-CZvLXFND.js";
+import { n as TopicPort } from "./watch-topic-CloXeDTO.js";
+import { n as Controller, t as AuthPort } from "./controller-lWRcKqCl.js";
+//#region src/blocks/announcements/announcements.d.ts
+type AnnouncementSeverity = "info" | "success" | "warning" | "critical";
+/**
+ * Who sees it: everyone, members of some tenants, members with some roles, or
+ * tenants on some plans (entitlement lookup keys, with the entitlements
+ * module).
+ */
+type AnnouncementAudience = {
+  readonly type: "all";
+} | {
+  readonly type: "tenant";
+  readonly organizationIds: readonly string[];
+} | {
+  readonly type: "role";
+  readonly roles: readonly string[];
+} | {
+  readonly type: "plan";
+  readonly plans: readonly string[];
+};
+interface Announcement {
+  readonly id: string;
+  readonly title: string;
+  readonly body: string;
+  readonly severity: AnnouncementSeverity;
+  readonly href: string | undefined;
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant | undefined;
+  readonly dismissible: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** An announcement as staff see it, with its audience. */
+interface ManagedAnnouncement extends Announcement {
+  readonly audience: AnnouncementAudience;
+  readonly createdBy: string | undefined;
+}
+interface AnnouncementInput {
+  readonly title: string;
+  /** Plain text or Markdown; the app renders it. */
+  readonly body?: string;
+  readonly severity?: AnnouncementSeverity;
+  /** A link for "Learn more": `https://` or a path. */
+  readonly href?: string | null;
+  readonly audience?: AnnouncementAudience;
+  readonly startsAt?: Temporal.Instant;
+  readonly endsAt?: Temporal.Instant | null;
+  readonly dismissible?: boolean;
+}
+interface AnnouncementsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the announcement columns the app adds
+   * (`blocks.announcements.options.extraColumns`), keyed by column name. It
+   * types and parses them on every read, and validates them on `publish` and
+   * `update`, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Announcements<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** `F` is the extra fields `options.fields` describes. */
+interface Announcements<F extends object = Record<never, never>> {
+  /**
+   * The caller's live, undismissed announcements; pass the active tenant for
+   * tenant, role and plan audiences.
+   */
+  listActive(organizationId?: string | null): AsyncResult<readonly (Announcement & F)[]>;
+  /** Hides one for the caller; `false` when it was hidden already. */
+  dismiss(announcementId: string): AsyncResult<boolean>;
+  /** Every announcement; needs `announcements.manage` on the platform. */
+  list(): AsyncResult<readonly (ManagedAnnouncement & F)[]>;
+  /** Keys besides the input's own are the announcement's extra columns. */
+  publish(input: AnnouncementInput & Partial<F>): AsyncResult<ManagedAnnouncement & F>;
+  update(announcementId: string, input: Partial<AnnouncementInput> & Partial<F>): AsyncResult<ManagedAnnouncement & F>;
+  remove(announcementId: string): AsyncResult<boolean>;
+}
+declare function createAnnouncements<S extends StandardSchemaV1 | undefined = undefined>(options: AnnouncementsOptions<S>): Announcements<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/announcements/client.d.ts
+interface AnnouncementsControllerOptions {
+  readonly client: Pick<Announcements, "listActive" | "dismiss">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The active tenant, for tenant, role and plan audiences. */
+  readonly organizationId?: string | null;
+  /**
+   * The topic the module broadcasts to
+   * (`blockConfig.announcements.options.topic` from `blocks.generated.ts`);
+   * `null` loads once.
+   */
+  readonly topic?: string | null;
+}
+interface AnnouncementsSnapshot {
+  /** `undefined` until the first load. */
+  readonly items: readonly Announcement[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AnnouncementsActions {
+  /** Hides one for the user, then drops it from `items`. */
+  readonly dismiss: (announcementId: string) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+type AnnouncementsController = Controller<AnnouncementsSnapshot, AnnouncementsActions>;
+/**
+ * The signed-in user's live announcements, loaded again whenever staff publish,
+ * change or remove one.
+ */
+declare function createAnnouncementsController(options: AnnouncementsControllerOptions): AnnouncementsController;
+//#endregion
+export { createAnnouncementsController as a, AnnouncementInput as c, AnnouncementsOptions as d, ManagedAnnouncement as f, AnnouncementsSnapshot as i, AnnouncementSeverity as l, AnnouncementsController as n, Announcement as o, createAnnouncements as p, AnnouncementsControllerOptions as r, AnnouncementAudience as s, AnnouncementsActions as t, Announcements as u };

package/dist/client-DScMvaty.js

@@ -0,0 +1,38 @@
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/usage/client.ts
+function readingOf(status) {
+	const limit = status.unlimited ? void 0 : status.limit;
+	return {
+		...status,
+		fraction: limit === void 0 ? void 0 : limit === 0 ? 1 : Math.min(1, status.used / limit),
+		exceeded: limit !== void 0 && status.used >= limit
+	};
+}
+/** This period's usage of an organization against its plan's quotas, per meter. */
+function createUsageMeterController(options) {
+	const { client, organizationId, meters } = options;
+	const pick = (all) => meters === void 0 ? all : meters.flatMap((meter) => all.filter((each) => each.meter === meter));
+	return defineController({
+		meters: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			if (organizationId === null) return;
+			const run = state.run();
+			const result = await client.overview(organizationId);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				meters: pick(result.data).map(readingOf),
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: { refresh },
+			start: () => organizationId === null ? void 0 : whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+//#endregion
+export { createUsageMeterController as t };