better-supabase 0.13.0 → 0.15.0

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

@@ -1,7 +1,136 @@
-import { _ as AnnouncementEventData, wt as Events } from "../../events-DhGgwqQA.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { a as createAnnouncementsController, c as AnnouncementInput, d as AnnouncementsOptions, f as ManagedAnnouncement, i as AnnouncementsSnapshot, l as AnnouncementSeverity, n as AnnouncementsController, o as Announcement, p as createAnnouncements, r as AnnouncementsControllerOptions, s as AnnouncementAudience, t as AnnouncementsActions, u as Announcements } from "../../client-DEE57s9m.js";
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, b as DbError, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "../../standard-DBV730sF.js";
+import { r as FieldsOf } from "../../block-fields-BE7pInWZ.js";
+import { Ct as Events, _ as AnnouncementEventData } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { c as BlockOf } from "../../define-block-BVcLQ3DF.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";
+//#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>;
+}
+export 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.
+ */
+export declare function createAnnouncementsController(options: AnnouncementsControllerOptions): AnnouncementsController;
+//#endregion
 //#region src/blocks/announcements/events.d.ts
 /** The events of the `announcements` block: type to data. */
 type AnnouncementsEvents = {
@@ -15,4 +144,4 @@ export declare const announcementsEvents: Events<AnnouncementsEvents>;
 /** The `announcements` block's manifest (ADR 0029). */
 export declare const announcementsBlock: BlockOf<"announcements", typeof createAnnouncements, AnnouncementsEvents>;
 //#endregion
-export { type Announcement, type AnnouncementAudience, type AnnouncementInput, type AnnouncementSeverity, type Announcements, type AnnouncementsActions, type AnnouncementsController, type AnnouncementsControllerOptions, type AnnouncementsEvents, type AnnouncementsOptions, type AnnouncementsSnapshot, type BlockTransport, type ManagedAnnouncement, createAnnouncements, createAnnouncementsController, dbTransport, rpcTransport, sqlTransport };
+export { type Announcement, type AnnouncementAudience, type AnnouncementInput, type AnnouncementSeverity, type Announcements, type AnnouncementsActions, type AnnouncementsController, type AnnouncementsControllerOptions, type AnnouncementsEvents, type AnnouncementsOptions, type AnnouncementsSnapshot, type BlockTransport, type ManagedAnnouncement, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/announcements/index.js

@@ -1,9 +1,184 @@
+import { t as AsyncResult } from "../../result-ntFBW2p2.js";
 import { t as announcementsSqlOptions } from "../../options-oeAq4Ho5.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { B as dbTransport, C as optionalText, D as recordOf, F as stringsOf, H as rpcTransport, I as textOf, R as toInstant, S as optionalInstant, U as sqlTransport, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-Ds0C2mUf.js";
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { t as createAnnouncements } from "../../announcements-DqiLxtKK.js";
-import { t as createAnnouncementsController } from "../../client--tyFmxDT.js";
+import { c as withFields, i as extraOf, n as blockFields, t as allWithFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+//#region src/blocks/announcements/announcements.ts
+const SEVERITIES = /* @__PURE__ */ new Set([
+	"info",
+	"success",
+	"warning",
+	"critical"
+]);
+function severityOf(value) {
+	const text = textOf(value);
+	return SEVERITIES.has(text) ? text : "info";
+}
+function announcementOf(value) {
+	const row = recordOf(value, "announcements");
+	return {
+		id: textOf(row["id"]),
+		title: textOf(row["title"]),
+		body: textOf(row["body"] ?? ""),
+		severity: severityOf(row["severity"]),
+		href: optionalText(row["href"]),
+		startsAt: toInstant(textOf(row["starts_at"])),
+		endsAt: optionalInstant(row["ends_at"]),
+		dismissible: row["dismissible"] !== false,
+		createdAt: toInstant(textOf(row["created_at"])),
+		updatedAt: toInstant(textOf(row["updated_at"]))
+	};
+}
+function audienceOf(type, targets) {
+	const values = stringsOf(targets);
+	switch (type) {
+		case "tenant": return {
+			type,
+			organizationIds: values
+		};
+		case "role": return {
+			type,
+			roles: values
+		};
+		case "plan": return {
+			type,
+			plans: values
+		};
+		default: return { type: "all" };
+	}
+}
+function managedOf(value) {
+	const row = recordOf(value, "announcements");
+	return {
+		...announcementOf(row),
+		audience: audienceOf(row["audience"], row["targets"]),
+		createdBy: optionalText(row["created_by"])
+	};
+}
+function audienceFields(audience) {
+	switch (audience.type) {
+		case "all": return {
+			audience: "all",
+			targets: []
+		};
+		case "tenant": return {
+			audience: "tenant",
+			targets: audience.organizationIds
+		};
+		case "role": return {
+			audience: "role",
+			targets: audience.roles
+		};
+		case "plan": return {
+			audience: "plan",
+			targets: audience.plans
+		};
+		default: throw new TypeError(`Unknown audience ${JSON.stringify(audience)}`);
+	}
+}
+/** The columns `save_announcement` sets, from the fields the input names. */
+function fieldsOf(input) {
+	const fields = {};
+	if (input.title !== void 0) fields["title"] = input.title;
+	if (input.body !== void 0) fields["body"] = input.body;
+	if (input.severity !== void 0) fields["severity"] = input.severity;
+	if (input.href !== void 0) fields["href"] = input.href;
+	if (input.audience !== void 0) Object.assign(fields, audienceFields(input.audience));
+	if (input.startsAt !== void 0) fields["starts_at"] = instantArg(input.startsAt);
+	if (input.endsAt !== void 0) fields["ends_at"] = instantArg(input.endsAt);
+	if (input.dismissible !== void 0) fields["dismissible"] = input.dismissible;
+	return fields;
+}
+const INPUT_KEYS = /* @__PURE__ */ new Set([
+	"title",
+	"body",
+	"severity",
+	"href",
+	"audience",
+	"startsAt",
+	"endsAt",
+	"dismissible"
+]);
+function createAnnouncements(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "announcement fields");
+	const save = (id, input) => {
+		const columns = fieldsOf(input);
+		return AsyncResult.from(() => fields.write(extraOf(input, INPUT_KEYS))).andThen((extra) => call("save_announcement", {
+			id,
+			fields: {
+				...extra,
+				...columns
+			}
+		}, (value) => value)).andThen((value) => withFields(fields, value, managedOf(value)));
+	};
+	return withBlockHooks({
+		listActive: (organizationId) => call("active_announcements", { tenant: organizationId ?? null }, (value) => recordsOf(value, "active_announcements").map((raw) => [raw, announcementOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+		dismiss: (announcementId) => call("dismiss_announcement", { id: announcementId }, (value) => value === true),
+		list: () => call("list_announcements", {}, (value) => recordsOf(value, "list_announcements").map((raw) => [raw, managedOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+		publish: (input) => save(null, input),
+		update: (announcementId, input) => save(announcementId, input),
+		remove: (announcementId) => call("delete_announcement", { id: announcementId }, (value) => value === true)
+	}, options.hooks, {
+		block: "announcements",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/announcements/client.ts
+/**
+* The signed-in user's live announcements, loaded again whenever staff publish,
+* change or remove one.
+*/
+function createAnnouncementsController(options) {
+	const { client } = options;
+	const organizationId = options.organizationId ?? null;
+	const topic = options.topic === void 0 ? "announcements" : options.topic;
+	return defineController({
+		items: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const result = await client.listActive(organizationId);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				items: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: {
+				refresh,
+				dismiss: async (announcementId) => {
+					const result = await client.dismiss(announcementId);
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					state.set((current) => ({ items: current.items?.filter((item) => item.id !== announcementId) }));
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+				if (!topic) return;
+				return options.ports.topic(topic, {
+					onMessage: () => void refresh(),
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave;
+			})
+		};
+	});
+}
+//#endregion
 //#region src/blocks/announcements/events.ts
 /** The `announcements` block's event types, for its manifest and `onBlockEvent`. */
 const announcementsEvents = defineEvents({

package/dist/blocks/api-keys/index.d.ts

@@ -1,10 +1,11 @@
-import { v as ApiKeyEventData, wt as Events } from "../../events-DhGgwqQA.js";
-import { r as AuthState } from "../../resolve-D57oDWNr.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { t as BlockProblemOptions } from "../../problem-D_DEBfMn.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { _ as createApiKeys, a as ApiKeyExtraClaims, c as ApiKeyState, d as CreateApiKeyInput, f as CreatedApiKey, g as apiKeyResolver, h as apiKeyClaims, i as ApiKeyExtraClaim, l as ApiKeys, m as apiKeyChecksum, n as ApiKeyCheck, o as ApiKeyReservedClaim, p as ParsedApiKey, r as ApiKeyClaimsOptions, s as ApiKeyResolverOptions, t as ApiKey, u as ApiKeysOptions, v as parseApiKey } from "../../api-keys-Bade6Qtl.js";
-import { a as ApiKeysControllerOptions, i as ApiKeysController, n as ApiKeyDraft, o as ApiKeysSnapshot, r as ApiKeysActions, s as createApiKeysController, t as ApiKeyChange } from "../../client-CMqO1gCn.js";
+import { b as DbError, f as Result } from "../../result-DZeA5KS6.js";
+import { Ct as Events, v as ApiKeyEventData } from "../../events-vcqenSYU.js";
+import { r as AuthState } from "../../resolve-CXX6DHv3.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { t as BlockProblemOptions } from "../../problem-DNwN8iGz.js";
+import { c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller, t as AuthPort } from "../../controller-BrP0gn47.js";
+import { _ as createApiKeys, a as ApiKeyExtraClaims, c as ApiKeyState, d as CreateApiKeyInput, f as CreatedApiKey, g as apiKeyResolver, h as apiKeyClaims, i as ApiKeyExtraClaim, l as ApiKeys, m as apiKeyChecksum, n as ApiKeyCheck, o as ApiKeyReservedClaim, p as ParsedApiKey, r as ApiKeyClaimsOptions, s as ApiKeyResolverOptions, t as ApiKey, u as ApiKeysOptions, v as parseApiKey } from "../../api-keys-D5k63K6y.js";
 import { Entry } from "@supabase/middleware";
 import { AuthMode, JWTClaims, UserClaims } from "@supabase/server";
 //#region src/blocks/api-keys/pipeline.d.ts
@@ -38,6 +39,66 @@ interface ApiKeyContributions {
  */
 export declare function withApiKey<F extends object = Record<never, never>>(options: WithApiKeyOptions<F>): Entry<ApiKeyContributions>;
 //#endregion
+//#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.
+ */
+export declare function createApiKeysController(options: ApiKeysControllerOptions): ApiKeysController;
+//#endregion
 //#region src/blocks/api-keys/events.d.ts
 /** The events of the `api-keys` block: type to data. */
 type ApiKeysEvents = {
@@ -52,4 +113,4 @@ export declare const apiKeysEvents: Events<ApiKeysEvents>;
 /** The `api-keys` block's manifest (ADR 0029). */
 export declare const apiKeysBlock: BlockOf<"api-keys", typeof createApiKeys, ApiKeysEvents>;
 //#endregion
-export { type ApiKey, type ApiKeyAuth, type ApiKeyChange, type ApiKeyCheck, type ApiKeyClaimsOptions, type ApiKeyContributions, type ApiKeyDraft, type ApiKeyExtraClaim, type ApiKeyExtraClaims, type ApiKeyReservedClaim, type ApiKeyResolverOptions, type ApiKeyState, type ApiKeys, type ApiKeysActions, type ApiKeysController, type ApiKeysControllerOptions, type ApiKeysEvents, type ApiKeysOptions, type ApiKeysSnapshot, type BlockTransport, type CreateApiKeyInput, type CreatedApiKey, type ParsedApiKey, type WithApiKeyOptions, apiKeyChecksum, apiKeyClaims, apiKeyResolver, createApiKeys, createApiKeysController, dbTransport, parseApiKey, rpcTransport, sqlTransport };
+export { type ApiKey, type ApiKeyAuth, type ApiKeyChange, type ApiKeyCheck, type ApiKeyClaimsOptions, type ApiKeyContributions, type ApiKeyDraft, type ApiKeyExtraClaim, type ApiKeyExtraClaims, type ApiKeyReservedClaim, type ApiKeyResolverOptions, type ApiKeyState, type ApiKeys, type ApiKeysActions, type ApiKeysController, type ApiKeysControllerOptions, type ApiKeysEvents, type ApiKeysOptions, type ApiKeysSnapshot, type BlockTransport, type CreateApiKeyInput, type CreatedApiKey, type ParsedApiKey, type WithApiKeyOptions, apiKeyChecksum, apiKeyClaims, apiKeyResolver, createApiKeys, dbTransport, parseApiKey, rpcTransport, sqlTransport };