better-supabase 0.14.0 → 0.15.1

package/dist/store-o0HwYXl8.d.ts

@@ -1,83 +0,0 @@
-import { t as AsyncResult } from "./result-C6jDfedy.js";
-//#region src/streams/store.d.ts
-/** How a stream is opened. */
-interface StreamOpenOptions {
-  /** The user who may read the stream and cancel it. */
-  readonly owner?: string;
-  readonly tenant?: string;
-  /**
-   * What the stream carries, such as `chat` or `workflow`. Defaults to
-   * `default`.
-   */
-  readonly kind?: string;
-  /**
-   * Seconds the stream lives, or a Postgres interval such as `"2 hours"`.
-   * Defaults to one day.
-   */
-  readonly ttl?: number | string;
-}
-interface StreamAppendResult {
-  /** The index the next chunk gets. */
-  readonly next: number;
-  /** Someone asked the writer to stop. */
-  readonly cancelled: boolean;
-}
-interface StreamStatus {
-  /** The number of chunks stored. */
-  readonly next: number;
-  readonly closed: boolean;
-  readonly cancelled: boolean;
-}
-interface StreamReadOptions {
-  /** Ends the stream early. */
-  readonly signal?: AbortSignal;
-}
-interface StreamPurgeOptions {
-  /**
-   * How long a closed stream is kept: seconds or an interval. Defaults to one
-   * day.
-   */
-  readonly olderThan?: number | string;
-}
-/**
- * Durable, resumable output: one writer appends ordered text chunks and any
- * number of readers read from a chunk index, live or after a reconnect. Chunks
- * keep the index they were appended at, so a reader that counted `n` chunks
- * resumes with `read(id, n)`.
- */
-interface StreamStore {
-  readonly apiVersion: 1;
-  readonly name: string;
-  /** Creates the stream; `true` when it was new, `false` when it existed. */
-  open(id: string, options?: StreamOpenOptions): AsyncResult<boolean>;
-  /**
-   * Stores `chunks` at `fromIdx`, `fromIdx + 1`, ... Indexes already stored are
-   * skipped, so a retried batch is harmless. Fails with the hint
-   * `STREAM_NOT_FOUND`, `STREAM_CLOSED` or `STREAM_GAP` (`fromIdx` past the
-   * end).
-   */
-  append(id: string, fromIdx: number, chunks: readonly string[]): AsyncResult<StreamAppendResult>;
-  /**
-   * The chunks from `fromIdx` on, waiting for new ones until the stream is
-   * closed. A stream that doesn't exist (or that the caller can't read) ends at
-   * once. A read error errors the stream with the `DbError`.
-   */
-  read(id: string, fromIdx?: number, options?: StreamReadOptions): ReadableStream<string>;
-  /** The stream's state, or `undefined` when it doesn't exist. */
-  status(id: string): AsyncResult<StreamStatus | undefined>;
-  isCancelled(id: string): AsyncResult<boolean>;
-  /**
-   * Marks the stream finished; `false` when it was closed already or doesn't
-   * exist.
-   */
-  close(id: string): AsyncResult<boolean>;
-  /** Asks the writer to stop; it learns on its next append. */
-  cancel(id: string): AsyncResult<boolean>;
-  /**
-   * Deletes expired streams and closed ones past `olderThan`; resolves with the
-   * count.
-   */
-  purge(options?: StreamPurgeOptions): AsyncResult<number>;
-}
-//#endregion
-export { StreamStatus as a, StreamReadOptions as i, StreamOpenOptions as n, StreamStore as o, StreamPurgeOptions as r, StreamAppendResult as t };

package/dist/subject-readers-CsTpx44c.js

@@ -1,49 +0,0 @@
-import "./block-helpers-CiKtrb6g.js";
-//#region src/core/subject-readers.ts
-/**
-* A registered subject's type and id, from `subjects/<type>/<id>` or
-* `<type>/<id>`.
-*/
-function parseSubject(subject, types) {
-	const rest = subject.startsWith("subjects/") ? subject.slice(9) : subject;
-	const slash = rest.indexOf("/");
-	if (slash <= 0 || slash === rest.length - 1) return;
-	const type = rest.slice(0, slash);
-	return types.has(type) ? {
-		type,
-		id: rest.slice(slash + 1)
-	} : void 0;
-}
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
-* The default subscriber policy under an authorization provider: a subscriber
-* gets an event about a subject in `config.subjects` only when
-* `can_subject_for` says it may `read` the subject (the key in
-* `config.subjects.<type>.permissions`, never a share-link grant). Events
-* without a subject, or about a type the registry doesn't list, keep every
-* subscriber, so the block's own tenant check decides them. `transport` must
-* run as the service role.
-*/
-function subjectReaders(transport, options = {}) {
-	const schema = options.schema ?? "better_supabase";
-	const action = options.action ?? "read";
-	let types;
-	const registered = () => types ??= transport.call(schema, "subject_types", {}).then((value) => new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [])).catch((cause) => {
-		types = void 0;
-		throw cause;
-	});
-	return async (event, subscribers) => {
-		if (typeof event.subject !== "string" || subscribers.length === 0) return subscribers;
-		const subject = parseSubject(event.subject, await registered());
-		if (subject === void 0) return subscribers;
-		const allowed = await Promise.all(subscribers.map(async (subscriber) => UUID.test(subscriber.principal) ? await transport.call(schema, "can_subject_for", {
-			member: subscriber.principal,
-			subject_type: subject.type,
-			subject_id: subject.id,
-			action
-		}) === true : false));
-		return subscribers.filter((_, index) => allowed[index]);
-	};
-}
-//#endregion
-export { subjectReaders as t };

package/dist/subject-readers-DEZ45DQF.d.ts

@@ -1,21 +0,0 @@
-import { t as BlockTransport } from "./block-transport-d53POsem.js";
-import { g as SubscriberPolicy } from "./authorization-hooks-dLmUO_PZ.js";
-//#region src/core/subject-readers.d.ts
-interface SubjectReadersOptions {
-  /** The schema of the `subjects` module. Default `better_supabase`. */
-  readonly schema?: string;
-  /** The `config.subjects` action to check. Default `read`. */
-  readonly action?: string;
-}
-/**
- * The default subscriber policy under an authorization provider: a subscriber
- * gets an event about a subject in `config.subjects` only when
- * `can_subject_for` says it may `read` the subject (the key in
- * `config.subjects.<type>.permissions`, never a share-link grant). Events
- * without a subject, or about a type the registry doesn't list, keep every
- * subscriber, so the block's own tenant check decides them. `transport` must
- * run as the service role.
- */
-declare function subjectReaders(transport: BlockTransport, options?: SubjectReadersOptions): SubscriberPolicy;
-//#endregion
-export { subjectReaders as n, SubjectReadersOptions as t };

package/dist/subjects-B6p4oAZJ.d.ts

@@ -1,78 +0,0 @@
-//#region src/config/types/subjects.d.ts
-/**
- * One entity the app's blocks attach to (`subjects.<type>`): a task, a
- * customer, a document. Every subject-bound SQL module reads these entries
- * unless its own `options.subjects` says otherwise. ADR 0020.
- */
-interface SubjectConfig {
-  /** `schema.table`, or a table in `public`. */
-  readonly table: string;
-  /** The id column. Defaults to `id`. */
-  readonly id?: string;
-  /**
-   * The id column's type, such as `uuid` or `bigint`, so lookups compare on the
-   * primary key's own type. Without it the column is compared as text.
-   */
-  readonly idType?: string;
-  /**
-   * The tenant column. Defaults to `organization_id`, or
-   * `<blocks.tenant.entities.organization>_id` when the tenant is renamed.
-   * `false` for a subject without a tenant, which modules that keep a tenant on
-   * every row skip.
-   */
-  readonly tenant?: string | false;
-  /** The column `subject_title` returns. */
-  readonly title?: string;
-  /**
-   * The path `subject_url` returns, with `{column}` placeholders:
-   * `/tasks/{id}`.
-   */
-  readonly url?: string;
-  /**
-   * A permission key per action (`read`, `write`, or an app action) that
-   * `can_subject` checks in the subject's tenant, on top of the row being
-   * visible to the caller. `read` is also the permission modules check before
-   * they attach rows to the subject.
-   */
-  readonly permissions?: Readonly<Record<string, string>>;
-  /**
-   * A scope the authorization provider declares whose ids are this subject's
-   * ids, so a grant on the record counts as well as one on the tenant.
-   */
-  readonly scope?: string;
-  /** Delete module rows for a subject when its row is deleted. */
-  readonly cascade?: boolean;
-  /**
-   * The column holding the soft-delete time. Blocks hide rows where it is set,
-   * metrics skip them, and `gen` makes it the table's `softDelete()` column.
-   */
-  readonly deletedAt?: string;
-  /** The columns a search index reads. */
-  readonly search?: {
-    readonly title?: string;
-    readonly body?: readonly string[];
-  };
-  /**
-   * The text column holding the subject's rank key, and the column it is
-   * grouped by (a board stage), for `move()`. ADR 0021.
-   */
-  readonly rank?: {
-    readonly column: string;
-    readonly group?: string;
-  };
-  /**
-   * The columns the versions block snapshots and restores, and whether it
-   * snapshots on each change. An app table's `subject.versions` sets it.
-   */
-  readonly versions?: {
-    readonly columns: readonly string[];
-    readonly auto: boolean;
-  };
-}
-/**
- * The app's subject types, keyed by type name (lowercase, digits and
- * underscores).
- */
-type SubjectsConfig = Readonly<Record<string, SubjectConfig>>;
-//#endregion
-export { SubjectsConfig as n, SubjectConfig as t };

package/dist/subjects-DXFmanh5.d.ts

@@ -1,90 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "./result-C6jDfedy.js";
-import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { n as BlockOptions } from "./block-helpers-BaugZlJV.js";
-import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
-//#region src/blocks/subjects/my-work-kinds.d.ts
-/** What a `my_work` item waits on. */
-type MyWorkKind = "assigned" | "approval" | "reminder" | "mention" | "sla";
-/** The kinds `my_work` returns, in the order the docs list them. */
-declare const MY_WORK_KINDS: readonly MyWorkKind[];
-//#endregion
-//#region src/blocks/subjects/subjects.d.ts
-/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
-declare const SUBJECT_TITLES_LIMIT = 500;
-interface SubjectsOptions extends BlockOptions {
-  /** `withBlockHooks` hooks around the client's methods. */
-  readonly hooks?: BlockHooks<Subjects>;
-  /** Receives the errors `after` hooks throw. Default: `console`. */
-  readonly logger?: Logger;
-}
-/** A subject with its title and path, from `config.subjects`. */
-interface ResolvedSubject extends SubjectRef {
-  /** The `title` column's value, when the type names one. */
-  readonly title?: string;
-  /** The `url` template filled in, such as `/customers/42`. */
-  readonly url?: string;
-}
-/** A record page's header and tab badges, from `record_summary`. */
-interface RecordSummary extends ResolvedSubject {
-  /** Rows per section the caller can read, for each installed section asked. */
-  readonly counts: Readonly<Record<string, number>>;
-  /** Per section, whether a row is newer than `seenAt`. */
-  readonly unread: Readonly<Record<string, boolean>>;
-}
-interface RecordSummaryOptions {
-  /** When the caller last saw the record; every section is read without it. */
-  readonly seenAt?: Temporal.Instant | null;
-}
-/** One thing waiting on the caller, from `my_work`. */
-interface MyWorkItem {
-  readonly kind: MyWorkKind;
-  /** The record it is about: the work item, or the approval's subject. */
-  readonly subject: SubjectRef;
-  /**
-   * The row that put it here: the work item, approval request, reminder,
-   * comment or SLA clock id.
-   */
-  readonly ref: string;
-  readonly title?: string;
-  readonly url?: string;
-  /** The due date, or when it arrived. */
-  readonly at?: Temporal.Instant;
-}
-/** The most items one `my_work` call returns. */
-declare const MY_WORK_LIMIT = 200;
-interface MyWorkOptions {
-  /** Only this organization's work. Default: every organization. */
-  readonly tenant?: string;
-  /** At most this many items, newest first. Default 50, at most 200. */
-  readonly pageSize?: number;
-}
-/** The subjects block's registry as typed calls. */
-interface Subjects {
-  /**
-   * Titles and paths for many subjects in one call, keyed by `subjectKey`
-   * (`type:id`). A subject the caller can't read, a soft-deleted row or an
-   * unknown type is left out.
-   */
-  resolve(refs: readonly SubjectRef[]): AsyncResult<Readonly<Record<string, ResolvedSubject>>>;
-  /**
-   * The subject's title and path with a count and unread state for each of
-   * `sections` (`comments`, `attachments`), in one round trip; `undefined` when
-   * the caller can't read the subject.
-   */
-  summary(subject: SubjectRef, sections: readonly string[], options?: RecordSummaryOptions): AsyncResult<RecordSummary | undefined>;
-  /**
-   * What waits on the caller across the installed blocks, newest first: open
-   * work items assigned to them, approvals they can decide, their reminders
-   * sent this week, recent mentions and SLA clocks warned on their work.
-   */
-  myWork(options?: MyWorkOptions): AsyncResult<readonly MyWorkItem[]>;
-}
-/**
- * The `subjects` module's `subject_titles` as a typed call, for lists and
- * mentions that show a link to each subject.
- */
-declare function createSubjects(options: SubjectsOptions): Subjects;
-//#endregion
-export { RecordSummaryOptions as a, Subjects as c, MY_WORK_KINDS as d, MyWorkKind as f, RecordSummary as i, SubjectsOptions as l, MyWorkItem as n, ResolvedSubject as o, MyWorkOptions as r, SUBJECT_TITLES_LIMIT as s, MY_WORK_LIMIT as t, createSubjects as u };

package/dist/subjects-DevU_atb.js

@@ -1,107 +0,0 @@
-import { a as ok, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { C as optionalText, S as optionalInstant, m as instantArg, o as blockCall } from "./block-helpers-CiKtrb6g.js";
-import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
-import { t as MY_WORK_KINDS } from "./my-work-kinds-BU3SlA-6.js";
-import { r as subjectKey } from "./block-subjects-Dzq5Xn_0.js";
-//#region src/blocks/subjects/subjects.ts
-/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
-const SUBJECT_TITLES_LIMIT = 500;
-/** The most items one `my_work` call returns. */
-const MY_WORK_LIMIT = 200;
-function resolvedOf(value) {
-	if (!isRecord(value)) return;
-	const type = optionalText(value["type"]);
-	const id = optionalText(value["id"]);
-	if (type === void 0 || id === void 0) return;
-	const title = optionalText(value["title"]);
-	const url = optionalText(value["url"]);
-	return {
-		type,
-		id,
-		...title === void 0 ? {} : { title },
-		...url === void 0 ? {} : { url }
-	};
-}
-function numbersOf(value) {
-	return isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([key, each]) => typeof each === "number" ? [[key, each]] : [])) : {};
-}
-function flagsOf(value) {
-	return isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([key, each]) => typeof each === "boolean" ? [[key, each]] : [])) : {};
-}
-function summaryOf(value) {
-	const resolved = resolvedOf(value);
-	return resolved === void 0 || !isRecord(value) ? void 0 : {
-		...resolved,
-		counts: numbersOf(value["counts"]),
-		unread: flagsOf(value["unread"])
-	};
-}
-function workOf(value) {
-	if (!isRecord(value)) return;
-	const kind = MY_WORK_KINDS.find((each) => each === value["kind"]);
-	const subject = resolvedOf(value["subject"]);
-	const ref = optionalText(value["ref"]);
-	if (kind === void 0 || subject === void 0 || ref === void 0) return;
-	const title = optionalText(value["title"]);
-	const url = optionalText(value["url"]);
-	const at = optionalInstant(value["at"]);
-	return {
-		kind,
-		subject: {
-			type: subject.type,
-			id: subject.id
-		},
-		ref,
-		...title === void 0 ? {} : { title },
-		...url === void 0 ? {} : { url },
-		...at === void 0 ? {} : { at }
-	};
-}
-const workList = (value) => (Array.isArray(value) ? value : []).flatMap((row) => {
-	const item = workOf(row);
-	return item === void 0 ? [] : [item];
-});
-const resolvedList = (value) => (Array.isArray(value) ? value : []).flatMap((row) => {
-	const resolved = resolvedOf(row);
-	return resolved === void 0 ? [] : [resolved];
-});
-/**
-* The `subjects` module's `subject_titles` as a typed call, for lists and
-* mentions that show a link to each subject.
-*/
-function createSubjects(options) {
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	return withBlockHooks({
-		resolve: (refs) => AsyncResult.from(async () => {
-			const unique = [...new Map(refs.map((ref) => [subjectKey(ref), ref])).values()];
-			const chunks = [];
-			for (let start = 0; start < unique.length; start += 500) chunks.push(unique.slice(start, start + 500));
-			const results = await Promise.all(chunks.map((chunk) => call("subject_titles", { refs: chunk.map(({ type, id }) => ({
-				type,
-				id
-			})) }, resolvedList)));
-			const found = {};
-			for (const result of results) {
-				if (!result.ok) return result;
-				for (const subject of result.data) found[subjectKey(subject)] = subject;
-			}
-			return ok(found);
-		}),
-		summary: (subject, sections, summaryOptions = {}) => call("record_summary", {
-			subject_type: subject.type,
-			subject_id: subject.id,
-			sections: [...sections],
-			seen_at: instantArg(summaryOptions.seenAt) ?? null
-		}, summaryOf),
-		myWork: (workOptions = {}) => call("my_work", {
-			tenant: workOptions.tenant ?? null,
-			page_size: workOptions.pageSize ?? 50
-		}, workList)
-	}, options.hooks, {
-		block: "subjects",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-//#endregion
-export { SUBJECT_TITLES_LIMIT as n, createSubjects as r, MY_WORK_LIMIT as t };