better-supabase 0.13.0 → 0.15.0

package/dist/record-type-DRbnlj5q.js

@@ -0,0 +1,221 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { t as AsyncResult } from "./result-ntFBW2p2.js";
+import { t as can } from "./permissions-controller-BMsqIE5T.js";
+//#region src/records/bindings.ts
+/** The block key, module and binding a binding name refers to. */
+function findBinding(blocks, name) {
+	const binding = blocks[name]?.record;
+	return binding === void 0 ? void 0 : {
+		key: name,
+		module: binding.module ?? blocks[name]?.sql[0] ?? name,
+		binding
+	};
+}
+function clientOf(clients, key) {
+	return clients[key];
+}
+function missing(name, detail) {
+	return dbError("invalid_request", `Record binding "${name}" ${detail}`);
+}
+/**
+* A `can` for `loadBindings` from the caller's `PermissionSet` and the
+* `permissions` constant of `blocks.generated.ts`: a binding needs the key its
+* module's action names there. An action with no key there is allowed, and RLS
+* decides.
+*/
+function bindingCan(set, permissions) {
+	return ({ module, action }) => {
+		const key = permissions[module]?.[action];
+		return key === void 0 || can(set, key);
+	};
+}
+/**
+* Loads a record's bindings in parallel, each one settled: `ok` with its rows,
+* `error` with a `DbError`, or `hidden` when `can` says the caller can't read
+* it, which never runs its query. It never throws.
+*
+* ```ts
+* const { comments, tags } = await loadBindings(
+*   { blocks: blockSet.blocks, clients: blocks },
+*   { type: "customer", id },
+*   ["comments", "tags"],
+*   { can: bindingCan(permissionSet, permissions) },
+* );
+* ```
+*/
+async function loadBindings(source, subject, names, options = {}) {
+	const settled = await Promise.all(names.map(async (name) => {
+		const found = findBinding(source.blocks, name);
+		if (found === void 0) return [name, {
+			kind: "error",
+			error: missing(name, "is in no block")
+		}];
+		if (!(options.can?.({
+			binding: name,
+			module: found.module,
+			action: found.binding.permissions.read
+		}) ?? true)) return [name, { kind: "hidden" }];
+		const client = clientOf(source.clients, found.key);
+		if (client === void 0) return [name, {
+			kind: "error",
+			error: missing(name, `needs the "${found.key}" block built`)
+		}];
+		const load = found.binding.load;
+		const given = options.options?.[name];
+		const result = await load(client, subject, given);
+		return [name, result.ok ? {
+			kind: "ok",
+			data: result.data
+		} : {
+			kind: "error",
+			error: result.error
+		}];
+	}));
+	return Object.fromEntries(settled);
+}
+/**
+* How many rows a binding has for each of `subjects`, keyed by `subjectKey`
+* (`type:id`), for a badge on each row of a list. A binding without `count`
+* fails with `unsupported`.
+*/
+function countBinding(source, name, subjects) {
+	const found = findBinding(source.blocks, name);
+	const client = found && clientOf(source.clients, found.key);
+	if (found?.binding.count === void 0 || client === void 0) return AsyncResult.err(dbError("unsupported", `Record binding "${name}" can't count rows`));
+	const count = found.binding.count;
+	return count(client, subjects);
+}
+//#endregion
+//#region src/records/record-type.ts
+/** Describes one subject's record page from the blocks that own its bindings. */
+function defineRecordType(spec) {
+	const bindings = Object.entries(spec.blocks).flatMap(([key, block]) => block.record === void 0 ? [] : [key]);
+	return {
+		...spec,
+		bindings
+	};
+}
+/** The record a record type's page shows. */
+function recordSubject(feature, id) {
+	return {
+		type: feature.type,
+		id
+	};
+}
+/** The block key, module and write that `binding.write` names. */
+function findBindingWrite(feature, binding, write) {
+	const found = findBinding(feature.blocks, binding);
+	const entry = found?.binding.writes?.[write];
+	return found === void 0 || entry === void 0 ? void 0 : {
+		key: found.key,
+		module: found.module,
+		write: entry,
+		permission: entry.permission ?? found.binding.permissions.write
+	};
+}
+function keyOf(feature, module, action) {
+	return action === void 0 ? void 0 : feature.permissions?.[module]?.[action];
+}
+/**
+* The permission keys a record type's bindings check, for one
+* `access.permissions(keys)` call.
+*/
+function recordPermissionKeys(feature) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const name of feature.bindings) {
+		const found = findBinding(feature.blocks, name);
+		if (found === void 0) continue;
+		const { permissions, writes = {} } = found.binding;
+		const actions = [permissions.read, ...Object.values(writes).map((write) => write.permission ?? permissions.write)];
+		for (const action of actions) {
+			const key = keyOf(feature, found.module, action);
+			if (key !== void 0) keys.add(key);
+		}
+	}
+	return [...keys];
+}
+/**
+* What the caller may do on each of a record type's bindings, from its
+* `PermissionSet`. A binding action with no key in `permissions` is allowed,
+* and so is everything when `set` is `undefined` (no access block): RLS and
+* each function's checks decide.
+*/
+function recordCan(feature, set) {
+	const allowed = (module, action) => {
+		if (set === void 0) return true;
+		const key = keyOf(feature, module, action);
+		return key === void 0 || can(set, key);
+	};
+	return Object.fromEntries(feature.bindings.flatMap((name) => {
+		const found = findBinding(feature.blocks, name);
+		if (found === void 0) return [];
+		const { permissions, writes = {} } = found.binding;
+		return [[name, {
+			read: allowed(found.module, permissions.read),
+			...Object.fromEntries(Object.entries(writes).map(([write, entry]) => [write, allowed(found.module, entry.permission ?? permissions.write)]))
+		}]];
+	}));
+}
+/** The write names of each of a record type's bindings. */
+function bindingWrites(feature) {
+	return feature.bindings.map((binding) => [binding, Object.keys(findBinding(feature.blocks, binding)?.binding.writes ?? {})]);
+}
+/**
+* Runs `binding.write` with the client its block's creator made, which
+* `clients` holds under the block's key.
+*/
+function runBindingWrite(feature, clients, binding, write, subject, input) {
+	const found = findBindingWrite(feature, binding, write);
+	const client = clients[found?.key ?? ""];
+	if (found === void 0 || client === void 0) return AsyncResult.err(dbError("invalid_request", `Record binding "${binding}" has no write "${write}" with its block built`));
+	const run = found.write.run;
+	return run(client, subject, input);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A Standard Schema for `{ id, input }`: a non-empty record id and the input
+* `schema` validates, whose issues get the `input` path.
+*/
+function recordWriteInput(schema) {
+	const check = (inner, id) => inner.issues === void 0 ? { value: {
+		id,
+		input: inner.value
+	} } : { issues: inner.issues.map((issue) => ({
+		...issue,
+		path: ["input", ...issue.path ?? []]
+	})) };
+	return { "~standard": {
+		version: 1,
+		vendor: "better-supabase",
+		validate: (value) => {
+			if (!isObject(value)) return { issues: [{ message: "Expected an object" }] };
+			const { id, input } = value;
+			if (typeof id !== "string" || id === "") return { issues: [{
+				message: "Expected a record id",
+				path: ["id"]
+			}] };
+			const inner = schema["~standard"].validate(input ?? {});
+			return inner instanceof Promise ? inner.then((settled) => check(settled, id)) : check(inner, id);
+		}
+	} };
+}
+function isTemporal(value) {
+	return Object.prototype.toString.call(value).startsWith("[object Temporal.");
+}
+/**
+* `value` with every Temporal value replaced by its ISO 8601 string, for data
+* passed from a Server Component or returned from a Server Action.
+*/
+function plainData(value) {
+	const walk = (entry) => {
+		if (typeof entry !== "object" || entry === null) return entry;
+		if (isTemporal(entry)) return entry.toString();
+		if (Array.isArray(entry)) return entry.map(walk);
+		return Object.fromEntries(Object.entries(entry).map(([key, field]) => [key, walk(field)]));
+	};
+	return walk(value);
+}
+//#endregion
+export { recordCan as a, recordWriteInput as c, countBinding as d, findBinding as f, plainData as i, runBindingWrite as l, defineRecordType as n, recordPermissionKeys as o, loadBindings as p, findBindingWrite as r, recordSubject as s, bindingWrites as t, bindingCan as u };

package/dist/recordings-BBSJt_YV.d.ts

@@ -0,0 +1,119 @@
+/// <reference lib="esnext.temporal" />
+import { o as AiFile } from "./types-Dr9wZgNy.js";
+//#region src/blocks/activities/recordings.d.ts
+/** The queue a recording's transcription job goes on, with the jobs block. */
+declare const ENGAGEMENT_TRANSCRIBE_QUEUE = "engagements.transcribe";
+/** `pending` until a transcript is saved; `failed` when the transcriber gave up. */
+type EngagementRecordingStatus = "pending" | "transcribed" | "failed";
+/** A call or meeting recording: an ai-files file on an engagement. */
+interface EngagementRecording {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly engagementId: string;
+  readonly fileId: string;
+  readonly filename: string;
+  readonly mediaType: string;
+  readonly status: EngagementRecordingStatus;
+  /** A BCP 47 tag such as `en` or `nl-NL`, given or detected. */
+  readonly language?: string;
+  readonly durationSeconds?: number;
+  /** Why the transcriber failed. */
+  readonly error?: string;
+  /** The transcriber's model. */
+  readonly model?: string;
+  readonly segmentCount: number;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly transcribedAt?: Temporal.Instant;
+}
+/** One speaker turn of a transcript. */
+interface TranscriptSegment {
+  /** 1 for the first turn. */
+  readonly position: number;
+  /** The speaker's label, such as `Speaker 1` or a name. */
+  readonly speaker?: string;
+  /** The member who spoke, when known. */
+  readonly speakerUserId?: string;
+  /** Milliseconds from the start of the recording. */
+  readonly startMs: number;
+  readonly endMs: number;
+  readonly text: string;
+  /** Between 0 and 1. */
+  readonly confidence?: number;
+}
+type TranscriptSegmentInput = Omit<TranscriptSegment, "position">;
+/** What a transcriber returns and `saveTranscript` stores. */
+interface Transcript {
+  /** In order; `startMs` at most `endMs`. */
+  readonly segments: readonly TranscriptSegmentInput[];
+  readonly language?: string;
+  readonly durationSeconds?: number;
+}
+/** What `Transcriber.transcribe` gets for one recording. */
+interface TranscriberInput {
+  readonly file: Pick<AiFile, "id" | "filename" | "mediaType">;
+  /** A signed URL to the audio or video, for providers that fetch it. */
+  readonly url: string;
+  /** The bytes, for providers that take an upload. */
+  read(): Promise<Uint8Array>;
+  /** The language given when the recording was attached. */
+  readonly language?: string;
+}
+/**
+ * Turns a recording into speaker turns. Wrap any speech-to-text API or SDK in
+ * the app; the block imports none.
+ */
+interface Transcriber {
+  /** The transcriber contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+  readonly model: string;
+  transcribe(input: TranscriberInput, options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<Transcript>;
+}
+/** A follow-up a note names. */
+interface EngagementActionItem {
+  readonly text: string;
+  readonly ownerId?: string;
+  readonly dueAt?: Temporal.Instant;
+}
+/** What `saveNotes` stores and a note taker returns. */
+interface EngagementNotesInput {
+  readonly summary: string;
+  readonly actionItems?: readonly EngagementActionItem[];
+}
+/** The notes on an engagement: a summary and its action items. */
+interface EngagementNotes {
+  readonly engagementId: string;
+  readonly organizationId: string;
+  readonly summary: string;
+  readonly actionItems: readonly EngagementActionItem[];
+  /** The note taker's model, for notes an AI wrote. */
+  readonly model?: string;
+  /** `ai` from `summarize`, `member` when a member wrote them. */
+  readonly source: "ai" | "member";
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** What `NoteTaker.summarize` gets: the engagement and its transcripts. */
+interface NoteTakerInput<E> {
+  readonly engagement: E;
+  readonly transcript: readonly (TranscriptSegment & {
+    readonly recordingId: string;
+  })[];
+}
+/**
+ * Writes a summary and action items for an engagement from its transcripts.
+ * Wrap any model in the app; the block imports no AI SDK (ADR 0010).
+ */
+interface NoteTaker {
+  /** The note taker contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+  readonly model: string;
+  summarize<E>(input: NoteTakerInput<E>, options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<EngagementNotesInput>;
+}
+//#endregion
+export { EngagementRecording as a, NoteTakerInput as c, Transcript as d, TranscriptSegment as f, EngagementNotesInput as i, Transcriber as l, EngagementActionItem as n, EngagementRecordingStatus as o, TranscriptSegmentInput as p, EngagementNotes as r, NoteTaker as s, ENGAGEMENT_TRANSCRIBE_QUEUE as t, TranscriberInput as u };

package/dist/records/index.d.ts

@@ -0,0 +1,83 @@
+import { b as DbError, t as AsyncResult } from "../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../types-DFdg_4yN.js";
+import { _n as recordBindingWrite, an as RecordBindingDefinition, cn as RecordBindingResult, dn as RecordBindingWriteName, fn as RecordBindingWriteOutput, gn as defineRecordBinding, hn as TimelineItem, in as RecordBindingData, ln as RecordBindingWrite, mn as RecordRowInput, nn as AnyRecordBindingWrite, on as RecordBindingOptions, pn as RecordBindingWrites, rn as RecordBinding, sn as RecordBindingPermissions, tn as AnyRecordBinding, un as RecordBindingWriteInput, vn as recordEventMatches, yn as recordRowInput } from "../define-block-BVcLQ3DF.js";
+import { A as BindingBlocks, B as PermissionFlags, C as defineRecordType, D as recordPermissionKeys, E as recordCan, F as LoadBindingsOptions, H as can, I as LoadedBindings, L as bindingCan, M as BindingName, N as BindingOf, O as recordSubject, P as BindingSource, R as countBinding, S as RecordWriteInput, T as plainData, U as permissionFlags, V as PermissionSet, _ as RecordTypeBlocks, b as RecordTypeWriteInput, d as BindingWritesOf, f as Plain, g as RecordType, h as RecordCan, j as BindingCheck, k as recordWriteInput, m as PlainBindings, p as PlainBinding, v as RecordTypePermissions, w as findBindingWrite, x as RecordTypeWriteOutput, y as RecordTypeSpec, z as loadBindings } from "../index-DLq69k3F.js";
+import { p as SubscriptionStatus } from "../topic-CJrQZQaa.js";
+import { n as TopicPort } from "../watch-topic-BcGfvZOE.js";
+import { n as Controller, t as AuthPort } from "../controller-BrP0gn47.js";
+import { a as RecordSummaryOptions, c as Subjects, f as MyWorkKind, i as RecordSummary, n as MyWorkItem, r as MyWorkOptions } from "../subjects-BpIEN1MS.js";
+import { a as timelineBindings, c as RecordListCells, d as RecordListQuery, f as RecordListRow, h as defineRecordList, i as loadTimeline, l as RecordListColumn, m as RecordListSpec, n as Timeline, o as RecordList, p as RecordListSource, r as TimelineEntry, s as RecordListCell, t as LoadTimelineOptions, u as RecordListPage } from "../timeline-CtG0sehj.js";
+import { a as RecordFormOptions, c as recordForm, i as RecordFormInput, n as RecordFormCustomField, o as RecordFormResult, r as RecordFormField, s as RecordFormValues, t as RecordForm } from "../record-form-BYs9xv_N.js";
+//#region src/records/controller.d.ts
+interface RecordControllerOptions<B extends BindingBlocks, N extends BindingName<B>> extends LoadBindingsOptions<B, N> {
+  readonly source: BindingSource<B>;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The record to follow; nothing loads without one. */
+  readonly subject: RecordRef | null;
+  readonly bindings: readonly N[];
+  /**
+   * The one private topic that hears of changes to the record, such as a
+   * broadcast of its block events. A message whose event a binding lists in
+   * `events` loads that binding again; any other message loads every binding.
+   * Default `null`: bindings load again on `refresh` only.
+   */
+  readonly topic?: string | null;
+  /**
+   * The subjects client, to load `record_summary` (title, counts, unread) next
+   * to the bindings.
+   */
+  readonly summary?: Pick<Subjects, "summary">;
+  readonly summaryOptions?: RecordSummaryOptions;
+}
+interface RecordSnapshot<B extends BindingBlocks, N extends string> {
+  /** Each binding settled; `undefined` until the first load. */
+  readonly bindings: Partial<LoadedBindings<B, N>> | undefined;
+  /** The record's title, counts and unread state, with `summary`. */
+  readonly summary: RecordSummary | undefined;
+  readonly status: SubscriptionStatus;
+  /** The error of the last summary load. */
+  readonly error: DbError | undefined;
+}
+interface RecordActions<N extends string> {
+  /** Loads the named bindings again, or every binding and the summary. */
+  readonly refresh: (names?: readonly N[]) => Promise<void>;
+}
+type RecordController<B extends BindingBlocks, N extends string> = Controller<RecordSnapshot<B, N>, RecordActions<N>>;
+/**
+ * One record page's bindings for the signed-in user over one realtime
+ * subscription (ADR 0030): it loads them with `loadBindings`, and loads a
+ * binding again when `topic` carries one of its events.
+ */
+export declare function createRecordController<B extends BindingBlocks, const N extends BindingName<B>>(options: RecordControllerOptions<B, N>): RecordController<B, N>;
+//#endregion
+//#region src/records/my-work.d.ts
+/** What `loadMyWork` returns: the items, grouped by kind, and their counts. */
+interface MyWork {
+  /** Every item, newest first. */
+  readonly items: readonly MyWorkItem[];
+  /** The items of each kind, newest first; an empty list for a kind with none. */
+  readonly groups: Readonly<Record<MyWorkKind, readonly MyWorkItem[]>>;
+  /** How many items of each kind the page holds, for tab badges. */
+  readonly counts: Readonly<Record<MyWorkKind, number>>;
+}
+interface LoadMyWorkOptions extends MyWorkOptions {
+  /** Only these kinds, such as `["assigned", "approval"]`. Default: all. */
+  readonly kinds?: readonly MyWorkKind[];
+}
+/**
+ * The caller's "My work" page: `my_work` across the installed blocks, grouped
+ * by kind with a count each, in one round trip.
+ *
+ * ```ts
+ * const work = await loadMyWork(blocks.subjects, {
+ *   pageSize: 100,
+ * }).orThrow();
+ * work.groups.approval; // approvals the caller can decide
+ * ```
+ */
+export declare function loadMyWork(subjects: Pick<Subjects, "myWork">, options?: LoadMyWorkOptions): AsyncResult<MyWork>;
+//#endregion
+export { type AnyRecordBinding, type AnyRecordBindingWrite, type BindingBlocks, type BindingCheck, type BindingName, type BindingOf, type BindingSource, type BindingWritesOf, type LoadBindingsOptions, type LoadMyWorkOptions, type LoadTimelineOptions, type LoadedBindings, type MyWork, type MyWorkItem, type MyWorkKind, type MyWorkOptions, type PermissionFlags, type PermissionSet, type Plain, type PlainBinding, type PlainBindings, type RecordActions, type RecordBinding, type RecordBindingData, type RecordBindingDefinition, type RecordBindingOptions, type RecordBindingPermissions, type RecordBindingResult, type RecordBindingWrite, type RecordBindingWriteInput, type RecordBindingWriteName, type RecordBindingWriteOutput, type RecordBindingWrites, type RecordCan, type RecordController, type RecordControllerOptions, type RecordForm, type RecordFormCustomField, type RecordFormField, type RecordFormInput, type RecordFormOptions, type RecordFormResult, type RecordFormValues, type RecordList, type RecordListCell, type RecordListCells, type RecordListColumn, type RecordListPage, type RecordListQuery, type RecordListRow, type RecordListSource, type RecordListSpec, type RecordRowInput, type RecordSnapshot, type RecordSummary, type RecordSummaryOptions, type RecordType, type RecordTypeBlocks, type RecordTypePermissions, type RecordTypeSpec, type RecordTypeWriteInput, type RecordTypeWriteOutput, type RecordWriteInput, type Timeline, type TimelineEntry, type TimelineItem, bindingCan, can, countBinding, defineRecordBinding, defineRecordList, defineRecordType, findBindingWrite, loadBindings, loadTimeline, permissionFlags, plainData, recordBindingWrite, recordCan, recordEventMatches, recordForm, recordPermissionKeys, recordRowInput, recordSubject, recordWriteInput, timelineBindings };