better-supabase 0.12.0 → 0.13.0

package/dist/client-CMqO1gCn.d.ts

@@ -0,0 +1,64 @@
+import { b as DbError, f as Result } from "./result-mijqfoJN.js";
+import { n as Controller, t as AuthPort } from "./controller-lWRcKqCl.js";
+import { d as CreateApiKeyInput, f as CreatedApiKey, l as ApiKeys, t as ApiKey } from "./api-keys-Bade6Qtl.js";
+//#region src/blocks/api-keys/client.d.ts
+/** What `create` takes: the organization comes from the controller. */
+type ApiKeyDraft = Omit<CreateApiKeyInput, "organizationId">;
+/** A key change that committed, for `onChanged`. */
+type ApiKeyChange = {
+  readonly kind: "created";
+  readonly key: ApiKey;
+} | {
+  readonly kind: "revoked";
+  readonly id: string;
+};
+interface ApiKeysControllerOptions {
+  readonly client: Pick<ApiKeys, "list" | "create" | "revoke">;
+  readonly auth: AuthPort;
+  /**
+   * The organization whose keys to list and create: all of them for its
+   * managers, the caller's own for everyone else. `null` lists the caller's
+   * personal keys.
+   */
+  readonly organizationId: string | null;
+  /**
+   * Runs after a key was created or revoked, such as a server action that
+   * completes an onboarding step. A throw is kept in `error`.
+   */
+  readonly onChanged?: (change: ApiKeyChange) => void | Promise<void>;
+}
+interface ApiKeysSnapshot {
+  /** Newest first; `undefined` until the first load. */
+  readonly keys: readonly ApiKey[] | undefined;
+  /** Whether a key is being created. */
+  readonly creating: boolean;
+  /**
+   * The key `create` made, with its token, which is shown once; until
+   * `dismiss`.
+   */
+  readonly created: CreatedApiKey | undefined;
+  /** The key ids with a revoke in flight. */
+  readonly revoking: readonly string[];
+  readonly error: DbError | undefined;
+}
+interface ApiKeysActions {
+  /**
+   * Creates a key and keeps its token in `created`; a failure is also kept in
+   * `error`.
+   */
+  readonly create: (draft: ApiKeyDraft) => Promise<Result<CreatedApiKey>>;
+  /** Revokes a key at once, then loads the list again. */
+  readonly revoke: (id: string) => Promise<Result<boolean>>;
+  /** Forgets `created` and `error`, such as when the token dialog closes. */
+  readonly dismiss: () => void;
+  readonly refresh: () => Promise<void>;
+}
+type ApiKeysController = Controller<ApiKeysSnapshot, ApiKeysActions>;
+/**
+ * The API keys of an organization (or the caller's personal keys) for an API
+ * keys table: `create` returns the token once, `revoke` revokes a key, and both
+ * load the list again.
+ */
+declare function createApiKeysController(options: ApiKeysControllerOptions): ApiKeysController;
+//#endregion
+export { ApiKeysControllerOptions as a, ApiKeysController as i, ApiKeyDraft as n, ApiKeysSnapshot as o, ApiKeysActions as r, createApiKeysController as s, ApiKeyChange as t };

package/dist/client-CPirbPPi.js

@@ -0,0 +1,85 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { r as err } from "./result-DIT_qp4G.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+//#region src/blocks/comments/client.ts
+/**
+* One subject's comment thread for the signed-in user: loads it, keeps it
+* current after `add`, `edit` and `remove`, and loads it again for each message
+* on `topic`.
+*/
+function createCommentsController(options) {
+	const { client, organizationId, subjectType, subjectId } = options;
+	const topic = options.topic ?? null;
+	return defineController({
+		comments: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const refresh = async () => {
+			if (organizationId === null) return;
+			ticket += 1;
+			const request = ticket;
+			const result = await client.list(organizationId, subjectType, subjectId, options.limit === void 0 ? {} : { limit: options.limit });
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				comments: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const replace = (comment) => {
+			ticket += 1;
+			state.set((current) => {
+				const comments = current.comments ?? [];
+				return {
+					error: void 0,
+					comments: comments.some((each) => each.id === comment.id) ? comments.map((each) => each.id === comment.id ? comment : each) : [...comments, comment]
+				};
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				add: async (body, draft = {}) => {
+					if (organizationId === null) return err(dbError("invalid_input", "No organization is active"));
+					const result = await client.create({
+						...draft,
+						organizationId,
+						subjectType,
+						subjectId,
+						body
+					});
+					if (result.ok) replace(result.data);
+					else state.set({ error: result.error });
+					return result;
+				},
+				edit: async (id, edit) => {
+					const result = await client.edit(id, edit);
+					if (result.ok) replace(result.data);
+					else state.set({ error: result.error });
+					return result;
+				},
+				remove: async (id) => {
+					const result = await client.remove(id);
+					if (result.ok) await refresh();
+					else state.set({ error: result.error });
+					return result;
+				}
+			},
+			start: () => organizationId === null ? void 0 : whileSignedIn(options.auth, () => {
+				refresh();
+				if (topic === null) return;
+				const { leave } = options.ports.topic(topic, {
+					onMessage: () => void refresh(),
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				});
+				return leave;
+			})
+		};
+	});
+}
+//#endregion
+export { createCommentsController as t };

package/dist/client-CQPB-VJx.d.ts

@@ -0,0 +1,110 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-mijqfoJN.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 { n as Controller, t as AuthPort } from "./controller-lWRcKqCl.js";
+//#region src/blocks/onboarding/onboarding.d.ts
+type ChecklistScope = "user" | "organization";
+/** One step. `events` completes it when the outbox records one of those types. */
+interface ChecklistStep<Id extends string = string> {
+  readonly id: Id;
+  readonly title?: string;
+  readonly description?: string;
+  /** Where the step is done in the app, for a "Start" link. */
+  readonly href?: string;
+  readonly events?: readonly string[];
+}
+interface ChecklistSpec<Id extends string, Scope extends ChecklistScope> {
+  readonly id: string;
+  /** `user` tracks each user; `organization` tracks each tenant. */
+  readonly scope: Scope;
+  readonly steps: readonly ChecklistStep<Id>[];
+}
+interface OnboardingOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Onboarding>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A step with the subject's progress. */
+interface StepProgress<Id extends string> extends ChecklistStep<Id> {
+  readonly completed: boolean;
+  readonly completedAt: Temporal.Instant | undefined;
+  readonly completedBy: string | undefined;
+}
+interface ChecklistProgress<Id extends string> {
+  readonly steps: readonly StepProgress<Id>[];
+  readonly completed: number;
+  readonly total: number;
+  /** Every step is complete. */
+  readonly done: boolean;
+  /** The first step not done yet. */
+  readonly next: StepProgress<Id> | undefined;
+}
+/** The organization for an organization checklist; nothing for a user one. */
+type ChecklistSubject<Scope extends ChecklistScope> = Scope extends "organization" ? [organizationId: string] : [];
+/**
+ * The onboarding block: progress through any checklist `defineChecklist`
+ * declared.
+ */
+interface Onboarding {
+  /**
+   * The subject's progress: the caller's for a user checklist, the
+   * organization's otherwise.
+   */
+  progress<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, ...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
+  /** Marks a step done; `false` when it already was. */
+  complete<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+  /** Marks a step not done; `false` when it wasn't. */
+  reset<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+}
+/**
+ * A checklist `defineChecklist` checked; pass it to the onboarding client's
+ * methods.
+ */
+type Checklist<Id extends string, Scope extends ChecklistScope> = ChecklistSpec<Id, Scope>;
+/**
+ * Declares an onboarding checklist. Pass the result to
+ * `blocks.onboarding.options.checklists` so the database knows its steps, and
+ * to the methods of `createOnboarding` to read and complete them.
+ */
+declare function defineChecklist<const Id extends string, const Scope extends ChecklistScope>(spec: ChecklistSpec<Id, Scope>): Checklist<Id, Scope>;
+/**
+ * The onboarding block: reads and completes the steps of the checklists in
+ * `blocks.onboarding.options.checklists`, for the caller or an organization.
+ */
+declare function createOnboarding(options: OnboardingOptions): Onboarding;
+//#endregion
+//#region src/blocks/onboarding/client.d.ts
+/** The calls the controller makes for one checklist; `createOnboarding` fits. */
+interface OnboardingControllerClient<Id extends string, Scope extends ChecklistScope> {
+  progress(checklist: Checklist<Id, Scope>, ...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
+  complete(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+  reset(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+}
+interface OnboardingControllerOptions<Id extends string, Scope extends ChecklistScope> {
+  /** `createOnboarding({ transport })`. */
+  readonly client: OnboardingControllerClient<Id, Scope>;
+  /** The checklist, from `defineChecklist`. */
+  readonly checklist: Checklist<Id, Scope>;
+  readonly auth: AuthPort;
+  /** The organization, for an organization checklist; it waits without one. */
+  readonly organizationId?: string | null;
+}
+interface OnboardingSnapshot<Id extends string> {
+  /** `undefined` until the first load. */
+  readonly progress: ChecklistProgress<Id> | undefined;
+  readonly error: DbError | undefined;
+}
+interface OnboardingActions<Id extends string> {
+  /** Marks a step done, then loads the progress again. */
+  readonly complete: (step: Id) => Promise<void>;
+  readonly reset: (step: Id) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+type OnboardingController<Id extends string> = Controller<OnboardingSnapshot<Id>, OnboardingActions<Id>>;
+/** A checklist's progress for the signed-in user, or for an organization. */
+declare function createOnboardingController<Id extends string, Scope extends ChecklistScope>(options: OnboardingControllerOptions<Id, Scope>): OnboardingController<Id>;
+//#endregion
+export { defineChecklist as _, OnboardingSnapshot as a, ChecklistProgress as c, ChecklistStep as d, ChecklistSubject as f, createOnboarding as g, StepProgress as h, OnboardingControllerOptions as i, ChecklistScope as l, OnboardingOptions as m, OnboardingController as n, createOnboardingController as o, Onboarding as p, OnboardingControllerClient as r, Checklist as s, OnboardingActions as t, ChecklistSpec as u };

package/dist/client-CXbP_p02.d.ts

@@ -0,0 +1,156 @@
+/// <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 { n as BlockHooks } from "./block-hooks-BadAniNI.js";
+import { n as Controller } from "./controller-lWRcKqCl.js";
+import { _ as AttendeeRole, d as OccurrenceOptions, f as OccurrenceRange, g as AttendeeResponse, l as CalendarEvent, n as EventCalendarOptions, t as EventCalendarEvent, u as CalendarOccurrence, y as CalendarEventStatus } from "./event-calendar-E6AI-dgg.js";
+import { t as VisibleRange } from "./range-p5V4rBhZ.js";
+//#region src/blocks/calendar/calendar.d.ts
+interface CalendarOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  /**
+   * A Standard Schema for the event columns the app adds
+   * (`blocks.calendar.options.extraColumns`), keyed by column name. It types
+   * and parses them on `events`, and validates them on `save` and the
+   * occurrence edits, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Calendar<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface CalendarInfo {
+  readonly id: string;
+  readonly name: string;
+  readonly tz: string;
+  readonly color?: string;
+  readonly ownerType?: string;
+  readonly ownerId?: string;
+}
+/** The fields of an event to write. Fields left out keep their value on update. */
+interface CalendarEventInput {
+  readonly title?: string;
+  readonly description?: string | null;
+  readonly location?: string | null;
+  readonly startsAt?: Temporal.Instant;
+  readonly endsAt?: Temporal.Instant;
+  readonly allDay?: boolean;
+  readonly tz?: string;
+  readonly status?: CalendarEventStatus;
+  /** An RFC 5545 `RRULE` value, or `null` to end the recurrence. */
+  readonly rrule?: string | null;
+  readonly exdates?: readonly Temporal.Instant[];
+  readonly subjectType?: string | null;
+  readonly subjectId?: string | null;
+  readonly color?: string | null;
+  /** Only on insert. Default the new id. */
+  readonly uid?: string;
+}
+interface SavedCalendarEvent {
+  readonly id: string;
+  readonly uid: string;
+  readonly created: boolean;
+}
+interface CalendarImport {
+  readonly created: number;
+  readonly updated: number;
+  /** Events without a UID or DTSTART, and overrides of an unknown series. */
+  readonly skipped: number;
+}
+/** `F` is the extra event fields `options.fields` describes. */
+interface Calendar<F extends object = Record<never, never>> {
+  createCalendar(organizationId: string, name: string, options?: {
+    readonly tz?: string;
+    readonly ownerType?: string;
+    readonly ownerId?: string;
+  }): AsyncResult<{
+    readonly id: string;
+  }>;
+  deleteCalendar(id: string): AsyncResult<boolean>;
+  listCalendars(organizationId: string): AsyncResult<CalendarInfo[]>;
+  /**
+   * Inserts an event, or updates the one with `id`. Keys besides the input's
+   * own are the event's extra columns.
+   */
+  save(calendarId: string, input: CalendarEventInput & Partial<F> & {
+    readonly id?: string;
+  }): AsyncResult<SavedCalendarEvent>;
+  delete(eventId: string): AsyncResult<boolean>;
+  /** The rows that can fall in the range: events, series and their overrides. */
+  events(calendarIds: readonly string[], range: OccurrenceRange): AsyncResult<(CalendarEvent & F)[]>;
+  /** The occurrences in the range, series expanded. */
+  occurrences(calendarIds: readonly string[], range: OccurrenceRange, options?: OccurrenceOptions): AsyncResult<CalendarOccurrence[]>;
+  /** Changes one occurrence: an override for a series, else the event. */
+  editOccurrence(occurrence: CalendarOccurrence, changes: CalendarEventInput & Partial<F>): AsyncResult<SavedCalendarEvent>;
+  /**
+   * Changes an occurrence and every later one: splits the series, unless the
+   * occurrence is its first. Pass `rrule` when the change moves the weekday.
+   */
+  editFollowing(occurrence: CalendarOccurrence, changes: CalendarEventInput & Partial<F>): AsyncResult<{
+    readonly id: string;
+  }>;
+  /** Removes one occurrence of a series (an `EXDATE`), or a single event. */
+  cancelOccurrence(occurrence: CalendarOccurrence): AsyncResult<boolean>;
+  setAttendee(eventId: string, attendee: {
+    readonly email: string;
+    readonly name?: string;
+    readonly userId?: string;
+    readonly role?: AttendeeRole;
+  }): AsyncResult<boolean>;
+  removeAttendee(eventId: string, email: string): AsyncResult<boolean>;
+  /** The signed-in user answers an invitation. */
+  respond(eventId: string, response: AttendeeResponse): AsyncResult<boolean>;
+  /** Upserts the events of an iCalendar file by UID. */
+  importIcs(calendarId: string, text: string): AsyncResult<CalendarImport>;
+  /** The calendar's events as an iCalendar file. */
+  exportIcs(calendar: CalendarInfo, range?: OccurrenceRange): AsyncResult<string>;
+  /**
+   * The iCalendar feed of a share link to a calendar (`subjectType:
+   * "calendar"`), or `null` when the token is unknown, revoked or expired.
+   */
+  feed(token: string): AsyncResult<string | null>;
+}
+/** A `list_calendar_events` or `calendar_feed` row as an event. */
+declare function calendarEventOf(value: unknown): CalendarEvent;
+declare function createCalendar<S extends StandardSchemaV1 | undefined = undefined>(options: CalendarOptions<S>): Calendar<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/calendar/client.d.ts
+interface CalendarControllerOptions extends EventCalendarOptions {
+  readonly client: Pick<Calendar, "occurrences" | "editOccurrence" | "editFollowing" | "cancelOccurrence">;
+  readonly calendarIds: readonly string[];
+  /** The visible range; `setRange` changes it. */
+  readonly range: VisibleRange;
+}
+interface CalendarSnapshot {
+  /** `undefined` until the first load. */
+  readonly occurrences: readonly CalendarOccurrence[] | undefined;
+  /** The occurrences as event calendar events (ReUI's `CalendarEvent` shape). */
+  readonly events: readonly EventCalendarEvent<CalendarOccurrence>[];
+  readonly error: DbError | undefined;
+  /** True until the occurrences of the current range arrive. */
+  readonly loading: boolean;
+}
+interface CalendarActions {
+  readonly refresh: () => Promise<void>;
+  /** Saves one occurrence's change, then loads the range again. */
+  readonly editOccurrence: (occurrence: CalendarOccurrence, changes: CalendarEventInput) => Promise<boolean>;
+  /** Saves the change for this and every later occurrence, then loads again. */
+  readonly editFollowing: (occurrence: CalendarOccurrence, changes: CalendarEventInput) => Promise<boolean>;
+  readonly cancelOccurrence: (occurrence: CalendarOccurrence) => Promise<boolean>;
+  /** Shows another range; the current occurrences stay until its own arrive. */
+  readonly setRange: (range: VisibleRange) => void;
+}
+type CalendarController = Controller<CalendarSnapshot, CalendarActions>;
+/**
+ * The occurrences of some calendars in the visible range, typed for a headless
+ * event calendar such as ReUI's Event Calendar.
+ */
+declare function createCalendarController(options: CalendarControllerOptions): CalendarController;
+//#endregion
+export { createCalendarController as a, CalendarImport as c, SavedCalendarEvent as d, calendarEventOf as f, CalendarSnapshot as i, CalendarInfo as l, CalendarController as n, Calendar as o, createCalendar as p, CalendarControllerOptions as r, CalendarEventInput as s, CalendarActions as t, CalendarOptions as u };