better-supabase 0.7.1 → 0.9.0

package/dist/eve/index.js

@@ -1,8 +1,9 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
+import { n as isRecord } from "../guards-6F2bCtQR.js";
 import { a as tenantClaimPaths, n as claimAt, t as DEFAULT_CLAIMS } from "../claims-PqzCxaTD.js";
-import { i as resolveAuth } from "../resolve-tJZY3FEa.js";
-import { t as isAnonymousUser } from "../view-BeFcRV6G.js";
-import { d as isRecord } from "../block-helpers-DWHxHsEQ.js";
+import { r as resolveAuth } from "../resolve-CAR9oaKW.js";
+import { t as isAnonymousUser } from "../view-DZ63nqwt.js";
+import { t as importOptionalPeer } from "../optional-peer-Dx8TaYXw.js";
 //#region src/eve/ids.ts
 /** A UUID (version 8) from the SHA-256 of `input`, so the same input always gets the same id. */
 async function stableUuid(input) {
@@ -20,7 +21,7 @@ var EveAuthRejection = class extends Error {
 	response;
 	constructor(message, status = 401) {
 		super(message);
-		this.response = new Response(JSON.stringify({ error: message }), {
+		this.response = Response.json({ error: message }, {
 			status,
 			headers: { "content-type": "application/json" }
 		});
@@ -229,9 +230,9 @@ function persistSessions(options) {
 	});
 	const chatFor = async (ctx) => {
 		const auth = ctx.session.auth.initiator ?? ctx.session.auth.current;
-		if (auth?.principalType !== "user") return void 0;
+		if (auth?.principalType !== "user") return;
 		const organizationId = organizationOf(auth);
-		if (organizationId === void 0) return void 0;
+		if (organizationId === void 0) return;
 		const id = await chatIdOf(ctx.session.id);
 		await chats.chats.create(organizationId, {
 			id,
@@ -243,7 +244,7 @@ function persistSessions(options) {
 	};
 	const knownChat = async (ctx) => {
 		const auth = ctx.session.auth.initiator ?? ctx.session.auth.current;
-		if (auth?.principalType !== "user" || organizationOf(auth) === void 0) return void 0;
+		if (auth?.principalType !== "user" || organizationOf(auth) === void 0) return;
 		return chatIdOf(ctx.session.id);
 	};
 	const release = async (ctx, turnId, status, error) => {
@@ -348,14 +349,7 @@ const isToolsModule = (value) => isRecord(value) && typeof value["defineTool"] =
 * Loads `eve/tools` when the provider first builds its tools. The specifier
 * is a variable so bundlers leave the optional peer out.
 */
-async function loadTools() {
-	const specifier = "eve/tools";
-	try {
-		return await import(specifier);
-	} catch {
-		return;
-	}
-}
+const loadTools = () => importOptionalPeer("eve/tools");
 const isRecallResult = (value) => isRecord(value) && Array.isArray(value["messages"]) && value["messages"].every((message) => isRecord(message) && typeof message["content"] === "string");
 /**
 * An eve memory provider over the memory and knowledge blocks. Every read
@@ -372,9 +366,9 @@ function supabaseMemory(options) {
 	});
 	const target = async (ctx) => {
 		const auth = ctx.session.auth.current;
-		if (auth?.principalType !== "user") return void 0;
+		if (auth?.principalType !== "user") return;
 		const organizationId = organizationOf(auth);
-		if (organizationId === void 0) return void 0;
+		if (organizationId === void 0) return;
 		return {
 			organizationId,
 			namespace: {

package/dist/eve-DUF70Vgi.d.ts

@@ -0,0 +1,151 @@
+import { d as KnowledgeSearchOptions, r as Knowledge } from "./knowledge-BXQ2-V0a.js";
+import { t as Memory } from "./types-6oiy6rIa.js";
+//#region src/eve/types.d.ts
+/**
+ * eve's `SessionAuthContext`, typed structurally so this entry never imports
+ * eve. `attributes` carries `tenantId`, `roles` and `isAnonymous`.
+ */
+interface EveSessionAuth {
+  readonly authenticator: string;
+  readonly principalType: string;
+  readonly principalId: string;
+  readonly issuer?: string;
+  readonly subject?: string;
+  readonly attributes: Readonly<Record<string, string | readonly string[]>>;
+}
+/** The session part of the context eve passes to hooks, memory and connections. */
+interface EveSessionContext {
+  readonly session: {
+    readonly id: string;
+    readonly auth: {
+      readonly current: EveSessionAuth | null;
+      readonly initiator?: EveSessionAuth | null;
+    };
+  };
+}
+//#endregion
+//#region src/eve/eve.d.ts
+/** eve's `MemoryDocumentConflictError`, matched by name. */
+declare class MemoryDocumentConflictError extends Error {
+  override readonly name = "MemoryDocumentConflictError";
+  readonly key: string;
+  constructor(key: string);
+}
+/** The backend eve's `fileMemory({ backend })` reads and writes. */
+interface EveDocumentBackend {
+  /** The document backend contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+  read(input: {
+    readonly key: string;
+    readonly signal?: AbortSignal;
+  }): Promise<{
+    readonly content: string;
+    readonly version: string;
+  } | null>;
+  write(input: {
+    readonly key: string;
+    readonly content: string;
+    readonly expectedVersion: string | null;
+    readonly signal?: AbortSignal;
+  }): Promise<{
+    readonly content: string;
+    readonly version: string;
+  }>;
+}
+interface SupabaseDocumentBackendOptions {
+  /** `createMemory` on a service transport. */
+  readonly memory: Memory;
+  /** Prefixes every key, so apps can share the table. Defaults to `eve`. */
+  readonly scope?: string;
+}
+/**
+ * A document backend for eve's `fileMemory()` over the memory module's
+ * `memory_documents` table. A write with a stale version throws
+ * `MemoryDocumentConflictError`, so eve retries with the current document.
+ */
+declare function supabaseDocumentBackend(options: SupabaseDocumentBackendOptions): EveDocumentBackend;
+interface EveMessagePart {
+  readonly type: string;
+  readonly text?: unknown;
+}
+interface EveModelMessage {
+  readonly role: string;
+  readonly content: string | readonly EveMessagePart[];
+}
+/** The context eve passes to a memory provider's `tools`. */
+interface EveMemoryToolsContext extends EveSessionContext {
+  readonly memory: {
+    readonly scope: {
+      readonly key: string;
+    };
+    readonly slot?: string;
+  };
+}
+/** The context eve passes to a memory provider's recall and capture handlers. */
+interface EveMemoryContext extends EveMemoryToolsContext {
+  readonly operationId: string;
+  readonly messages?: readonly EveModelMessage[];
+  readonly turn?: {
+    readonly id: string;
+    readonly input: readonly EveModelMessage[];
+    readonly sequence?: number;
+  } | null;
+  readonly abortSignal?: AbortSignal;
+}
+interface EveRecallMessage {
+  readonly id?: string;
+  readonly content: string;
+}
+interface EveRecallResult {
+  readonly messages: readonly EveRecallMessage[];
+}
+/** A provider for eve's `defineMemory({ provider })`; pass it through `defineMemoryProvider`. */
+interface EveMemoryProvider {
+  readonly recall: {
+    "turn.started"(ctx: EveMemoryContext): Promise<EveRecallResult | null>;
+  };
+  readonly capture?: {
+    "turn.completed"?(ctx: EveMemoryContext): Promise<void>;
+  };
+  tools?(ctx: EveMemoryToolsContext): Promise<Readonly<Record<string, EveMemoryTool>> | null>;
+}
+/** A tool from eve's `defineTool`, as a memory provider returns it. */
+interface EveMemoryTool {
+  readonly description: string;
+  readonly inputSchema: unknown;
+  execute(input: never, context: never): unknown;
+}
+interface SupabaseMemoryOptions {
+  /** `createMemory` on a service transport: eve calls the provider outside a user request. */
+  readonly memory: Memory;
+  /** Tenant documents to search alongside the memories. */
+  readonly knowledge?: Knowledge;
+  /**
+   * The knowledge scopes to search. Defaults to the tenant's shared
+   * documents: the provider searches as the service role, so a wider scope
+   * can show one user's documents to another.
+   */
+  readonly knowledgeScopes?: KnowledgeSearchOptions["scopes"];
+  /** Archival memories and knowledge chunks to recall per turn. Defaults to 5. */
+  readonly k?: number;
+  /** The tenant of a principal. Defaults to `attributes.tenantId`. */
+  readonly organizationOf?: (auth: EveSessionAuth) => string | undefined;
+  /**
+   * Facts to keep from a finished turn (an LLM call of yours). Without it
+   * the provider stores only what the model saves with its `remember` tool.
+   */
+  readonly extract?: (messages: readonly EveModelMessage[], ctx: EveMemoryContext) => Promise<readonly string[]>;
+  /** Adds the `remember` and `forget` tools. Defaults to true. */
+  readonly tools?: boolean;
+  /** Returns `eve/tools`; defaults to importing it on first use. */
+  readonly load?: () => Promise<unknown>;
+}
+/**
+ * An eve memory provider over the memory and knowledge blocks. Every read
+ * and write is partitioned by the scope key and the signed-in user; recall
+ * stores its answer under the operation id, so a replayed recall returns the
+ * same messages.
+ */
+declare function supabaseMemory(options: SupabaseMemoryOptions): EveMemoryProvider;
+//#endregion
+export { EveMemoryToolsContext as a, MemoryDocumentConflictError as c, supabaseDocumentBackend as d, supabaseMemory as f, EveMemoryTool as i, SupabaseDocumentBackendOptions as l, EveSessionContext as m, EveMemoryContext as n, EveRecallMessage as o, EveSessionAuth as p, EveMemoryProvider as r, EveRecallResult as s, EveDocumentBackend as t, SupabaseMemoryOptions as u };

package/dist/event-calendar-DJXXMJ3x.d.ts

@@ -0,0 +1,217 @@
+/// <reference lib="esnext.temporal" />
+//#region src/blocks/calendar/ics.d.ts
+/** How an attendee takes part (RFC 5545 `ROLE`), in lowercase. */
+type AttendeeRole = "chair" | "required" | "optional" | "non-participant";
+/** An attendee's answer (RFC 5545 `PARTSTAT`), in lowercase. */
+type AttendeeResponse = "needs-action" | "accepted" | "declined" | "tentative";
+type CalendarEventStatus = "confirmed" | "tentative" | "cancelled";
+interface CalendarAttendee {
+  readonly email: string;
+  readonly name?: string;
+  readonly userId?: string;
+  readonly role: AttendeeRole;
+  readonly response: AttendeeResponse;
+}
+/** One `VEVENT`, ready for `importIcs` or `save`. */
+interface IcsEvent {
+  readonly uid: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly location?: string;
+  readonly startsAt: Temporal.Instant;
+  /** Exclusive, as in `DTEND`. */
+  readonly endsAt: Temporal.Instant;
+  readonly allDay: boolean;
+  /** The IANA zone the event's wall-clock times and recurrence follow. */
+  readonly tz: string;
+  readonly status: CalendarEventStatus;
+  readonly rrule?: string;
+  readonly exdates: readonly Temporal.Instant[];
+  /** `RECURRENCE-ID`: the occurrence of the series this event overrides. */
+  readonly originalStart?: Temporal.Instant;
+  readonly attendees: readonly CalendarAttendee[];
+}
+interface ParsedIcs {
+  /** `X-WR-CALNAME`, when the file has one. */
+  readonly name?: string;
+  /** `X-WR-TIMEZONE`, else `UTC`: the zone of floating and all-day times. */
+  readonly tz: string;
+  readonly events: readonly IcsEvent[];
+  /** `VEVENT`s without a `UID` or `DTSTART`, which are left out. */
+  readonly skipped: number;
+}
+/**
+ * Reads an iCalendar file (RFC 5545): unfolds lines, unescapes TEXT values
+ * and reads each `VEVENT`'s times, recurrence (`RRULE`, `EXDATE`,
+ * `RECURRENCE-ID`) and attendees. Times in a zone Temporal does not know,
+ * floating times and dates use `X-WR-TIMEZONE`, else UTC.
+ */
+declare function parseIcs(text: string): ParsedIcs;
+/** The event fields `toIcs` writes. `CalendarEvent` has all of them. */
+interface IcsSource {
+  readonly uid: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly location?: string;
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant;
+  readonly allDay: boolean;
+  readonly tz: string;
+  readonly status: CalendarEventStatus;
+  readonly rrule?: string;
+  readonly exdates: readonly Temporal.Instant[];
+  readonly originalStart?: Temporal.Instant;
+  readonly attendees?: readonly CalendarAttendee[];
+  readonly updatedAt?: Temporal.Instant;
+}
+interface ToIcsOptions {
+  readonly name?: string;
+  /** `X-WR-TIMEZONE`. */
+  readonly tz?: string;
+  readonly prodId?: string;
+  /** `DTSTAMP` for events without `updatedAt`. Default now. */
+  readonly now?: Temporal.Instant;
+}
+/**
+ * Writes events as an iCalendar file (RFC 5545): CRLF line ends, lines
+ * folded at 75 octets, escaped TEXT, and a `VTIMEZONE` for every zone a
+ * timed event uses, so recurrence keeps its wall-clock time across DST.
+ */
+declare function toIcs(events: readonly IcsSource[], options?: ToIcsOptions): string;
+//#endregion
+//#region src/blocks/calendar/occurrences.d.ts
+/** One row of `calendar_events`: a single event, a series or an override. */
+interface CalendarEvent {
+  readonly id: string;
+  readonly calendarId: string;
+  readonly uid: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly location?: string;
+  readonly startsAt: Temporal.Instant;
+  /** Exclusive. */
+  readonly endsAt: Temporal.Instant;
+  readonly allDay: boolean;
+  readonly tz: string;
+  readonly status: CalendarEventStatus;
+  /** The RFC 5545 `RRULE` value of a series, without the `RRULE:` prefix. */
+  readonly rrule?: string;
+  readonly exdates: readonly Temporal.Instant[];
+  /** The series an override belongs to. */
+  readonly recurrenceId?: string;
+  /** The occurrence of the series an override replaces. */
+  readonly originalStart?: Temporal.Instant;
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  readonly color?: string;
+  readonly attendees: readonly CalendarAttendee[];
+  readonly updatedAt?: Temporal.Instant;
+}
+/** One occurrence in a range: a single event, or one instance of a series. */
+interface CalendarOccurrence {
+  /** `${seriesId}::${originalStart}`, stable across edits of the occurrence. */
+  readonly key: string;
+  /** The row the occurrence comes from: the event, the series or its override. */
+  readonly event: CalendarEvent;
+  /** The series, for an occurrence of one (also when it is overridden). */
+  readonly series?: CalendarEvent;
+  readonly start: Temporal.Instant;
+  readonly end: Temporal.Instant;
+  /** Where the series put this occurrence before any override moved it. */
+  readonly originalStart: Temporal.Instant;
+  readonly allDay: boolean;
+  readonly recurring: boolean;
+}
+interface OccurrenceRange {
+  readonly from: Temporal.Instant;
+  readonly until: Temporal.Instant;
+}
+interface OccurrenceOptions {
+  /** Keep cancelled events and occurrences. Default false. */
+  readonly includeCancelled?: boolean;
+}
+/**
+ * Expands events into the occurrences that overlap `[from, until)`. Series
+ * expand with the reminders block's `expandRule` in their own zone, so a
+ * weekly 09:00 meeting stays at 09:00 across DST. `EXDATE`s drop
+ * occurrences, and overrides replace the occurrence they name, also when
+ * they move it out of the range.
+ */
+declare function expandOccurrences(events: readonly CalendarEvent[], range: OccurrenceRange, options?: OccurrenceOptions): CalendarOccurrence[];
+/** The rules of a series split at one of its occurrences. */
+interface SplitRules {
+  /** The series up to the occurrence before `at`: `UNTIL` instead of `COUNT`. */
+  readonly before: string;
+  /** The series from `at` on: the remaining `COUNT`, or the old `UNTIL`. */
+  readonly after: string;
+}
+/**
+ * Splits a series for "this and following": the first rule ends one second
+ * before `at` (RFC 5545 forbids `COUNT` with `UNTIL`, so it drops `COUNT`),
+ * and the second keeps the occurrences that are left.
+ */
+declare function splitRule(rrule: string, dtstart: Temporal.ZonedDateTime, at: Temporal.Instant): SplitRules;
+//#endregion
+//#region src/blocks/calendar/event-calendar.d.ts
+/**
+ * The event shape of a headless event calendar such as ReUI's Event
+ * Calendar (`CalendarEvent`), typed structurally: better-supabase imports
+ * no UI library.
+ */
+interface EventCalendarEvent<TData = unknown> {
+  readonly id: string;
+  readonly title: string;
+  readonly start: Date;
+  /** Exclusive. */
+  readonly end: Date;
+  readonly allDay?: boolean;
+  readonly recurringEventId?: string;
+  readonly originalStart?: Date;
+  readonly color?: string;
+  readonly readOnly?: boolean;
+  readonly resourceId?: string;
+  readonly data?: TData;
+}
+/** A row of a resource view (a person, room or calendar). */
+interface EventCalendarResource {
+  readonly id: string;
+  readonly title: string;
+  readonly color?: string;
+}
+interface EventCalendarOptions {
+  /** The resource an occurrence belongs to. Default its calendar id. */
+  readonly resourceOf?: (occurrence: CalendarOccurrence) => string | undefined;
+  /** Marks occurrences the user cannot move. */
+  readonly readOnly?: (occurrence: CalendarOccurrence) => boolean;
+}
+/**
+ * Occurrences as event calendar events. Each id is the occurrence key, so an
+ * overridden occurrence keeps its id; `data` carries the occurrence for
+ * `fromEventCalendarUpdate` and your own handlers.
+ */
+declare function toEventCalendarEvents(occurrences: readonly CalendarOccurrence[], options?: EventCalendarOptions): EventCalendarEvent<CalendarOccurrence>[];
+/** Calendars (or anything with an id and a name) as resources. */
+declare function toEventCalendarResources(items: readonly {
+  readonly id: string;
+  readonly name: string;
+  readonly color?: string;
+}[]): EventCalendarResource[];
+/** What a drag or resize asks for, in the shape `editOccurrence` takes. */
+interface OccurrenceMove {
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant;
+  readonly allDay?: boolean;
+}
+/**
+ * The new times of an `onEventUpdate` from an event calendar, for
+ * `calendar.editOccurrence(occurrence, move)` or `editFollowing`.
+ */
+declare function fromEventCalendarUpdate(update: {
+  readonly start: Date;
+  readonly end: Date;
+  readonly allDay?: boolean;
+}): OccurrenceMove;
+/** The series of an occurrence, or the event itself. */
+declare const seriesOf: (occurrence: CalendarOccurrence) => CalendarEvent;
+//#endregion
+export { ToIcsOptions as C, ParsedIcs as S, toIcs as T, AttendeeRole as _, fromEventCalendarUpdate as a, IcsEvent as b, toEventCalendarResources as c, OccurrenceOptions as d, OccurrenceRange as f, AttendeeResponse as g, splitRule as h, OccurrenceMove as i, CalendarEvent as l, expandOccurrences as m, EventCalendarOptions as n, seriesOf as o, SplitRules as p, EventCalendarResource as r, toEventCalendarEvents as s, EventCalendarEvent as t, CalendarOccurrence as u, CalendarAttendee as v, parseIcs as w, IcsSource as x, CalendarEventStatus as y };

package/dist/event-map-Dy2vKHai.js

@@ -0,0 +1,19 @@
+//#region src/core/event-map.ts
+/** The event `type` and its data type `T`, for `defineEvents`. */
+function event() {
+	return {};
+}
+/**
+* Declares events by type, so blocks, `defineBlocks` and `onBlockEvent`
+* type their data:
+* `defineEvents({ "invoice.sent": event<{ invoiceId: string }>() })`.
+*/
+function defineEvents(spec) {
+	return { types: Object.keys(spec) };
+}
+/** Several `Events` as one, such as a block's events and the app's own. */
+function mergeEvents(...events) {
+	return { types: [...new Set(events.flatMap((each) => each.types))] };
+}
+//#endregion
+export { event as n, mergeEvents as r, defineEvents as t };

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
-import { A as CredentialEventData, B as OrganizationEventData, C as BlockEventMap, D as BlockEventsMatching, E as BlockEventType, F as InvitationEventData, G as StorageObjectEventData, H as ScimEventData, I as InviteCodeEventData, J as WebhookEventData, K as SupportEventData, L as NotificationEventData, M as FlagEventData, N as InboxEventData, O as CommentEventData, P as IncomingWebhookEventData, Q as onBlockEvent, R as OrganizationDeletionEventData, S as BlockEvent, T as BlockEventPattern, U as SettingEventData, V as PushDeviceEventData, W as SsoProviderEventData, X as WorkflowRunEventData, Y as WorkflowEventData, Z as blockEventAttributes, _ as AttachmentEventData, b as BLOCK_EVENT_RENAMES, d as AgentEventData, f as AiChatEventData, g as ApiKeyEventData, h as AnnouncementEventData, j as DataExportEventData, k as ConnectorEventData, m as AiToolEventData, p as AiProviderKeyEventData, q as WaitlistEventData, v as AuditRevealEventData, w as BlockEventMeta, x as BillingEventData, y as BLOCK_ATTRIBUTES, z as OrganizationDomainEventData } from "../events-DWDhx77e.js";
-import { a as blockCloudEvent, i as ForwardBlockOptions, n as CloudEventOptions, o as forwardBlockEvents, r as EventSink, t as CloudEvent } from "../cloud-event-C1JCc1bH.js";
-import { a as RowEventData, c as httpSink, d as toHttp, i as ROW_EVENT_TYPES, l as isCloudEvent, n as HttpMode, o as forwardMutations, r as HttpSinkOptions, s as fromHttp, t as ForwardOptions, u as toCloudEvents } from "../index-ClmjK_o-.js";
-export { type AgentEventData, type AiChatEventData, type AiProviderKeyEventData, type AiToolEventData, type AnnouncementEventData, type ApiKeyEventData, type AttachmentEventData, type AuditRevealEventData, BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, type BillingEventData, type BlockEvent, type BlockEventMap, type BlockEventMeta, type BlockEventPattern, type BlockEventType, type BlockEventsMatching, type CloudEvent, type CloudEventOptions, type CommentEventData, type ConnectorEventData, type CredentialEventData, type DataExportEventData, type EventSink, type FlagEventData, type ForwardBlockOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InboxEventData, type IncomingWebhookEventData, type InvitationEventData, type InviteCodeEventData, type NotificationEventData, type OrganizationDeletionEventData, type OrganizationDomainEventData, type OrganizationEventData, type PushDeviceEventData, ROW_EVENT_TYPES, RowEventData, type ScimEventData, type SettingEventData, type SsoProviderEventData, type StorageObjectEventData, type SupportEventData, type WaitlistEventData, type WebhookEventData, type WorkflowEventData, type WorkflowRunEventData, blockCloudEvent, blockEventAttributes, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, onBlockEvent, toCloudEvents, toHttp };
+import { $ as SaasEventData, A as CollaborationEventData, B as FormEventData, C as BillingEventData, Ct as EventSpec, D as BlockEventPattern, Dt as event, E as BlockEventMeta, Et as defineEvents, F as CredentialEventData, G as InviteCodeEventData, H as InboxEventData, I as DataExportEventData, J as NotificationEventData, K as LegalHoldEventData, M as CommerceEventData, N as CommerceSubjectEventData, O as BlockEventType, Ot as mergeEvents, P as ConnectorEventData, Q as PushDeviceEventData, S as BLOCK_EVENT_RENAMES, St as EventMapOf, T as BlockEvent, Tt as MergedEventMap, U as IncomingWebhookEventData, V as FormSubmissionEventData, W as InvitationEventData, X as OrganizationDomainEventData, Y as OrganizationDeletionEventData, Z as OrganizationEventData, _ as AnnouncementEventData, _t as WorkflowRunEventData, at as SsoProviderEventData, b as AuditRevealEventData, bt as onBlockEvent, ct as SubjectEventType, dt as TemplateEventData, et as SaasSubjectEventData, ft as TimeEntryEventData, g as AiToolEventData, gt as WorkflowEventData, h as AiProviderKeyEventData, ht as WebhookEventData, it as SignatureEventData, j as CommentEventData, k as BlockEventsMatching, lt as SupportEventData, m as AiChatEventData, mt as WaitlistEventData, nt as ScimEventData, ot as StorageObjectEventData, p as AgentEventData, pt as TimesheetEventData, q as NotificationDeliveryEventData, rt as SettingEventData, st as SubjectEventData, tt as SchedulingEventData, ut as TemplateApplicationEventData, v as ApiKeyEventData, vt as blockEventAttributes, w as BlockEmit, wt as Events, x as BLOCK_ATTRIBUTES, xt as EventMap, y as AttachmentEventData, yt as emitBlockEvent, z as FlagEventData } from "../events-CTreRrgP.js";
+import { C as QuoteEventData, S as PipelineStageEventData, T as WorkItemEventData, _ as EngagementEventData, a as RowEventData, b as PartyEventData, c as httpSink, d as toHttp, f as ApplicationEventData, g as EmployeeEventData, h as DealEventData, i as ROW_EVENT_TYPES, l as isCloudEvent, m as CollectionEventData, n as HttpMode, o as forwardMutations, p as CollectionEntryEventData, r as HttpSinkOptions, s as fromHttp, t as ForwardOptions, u as toCloudEvents, v as InvoiceEventData, w as SlaEventData, x as PipelineEventData, y as JobEventData } from "../index-BlqrGvb3.js";
+import { a as ForwardBlockOptions, i as EventSink, n as CloudEventOptions, o as blockCloudEvent, r as DataschemaContext, s as forwardBlockEvents, t as CloudEvent } from "../cloud-event-5rCEzIgK.js";
+export { type AgentEventData, type AiChatEventData, type AiProviderKeyEventData, type AiToolEventData, type AnnouncementEventData, type ApiKeyEventData, type ApplicationEventData, type AttachmentEventData, type AuditRevealEventData, BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, type BillingEventData, type BlockEmit, type BlockEvent, type BlockEventMeta, type BlockEventPattern, type BlockEventType, type BlockEventsMatching, type CloudEvent, type CloudEventOptions, type CollaborationEventData, type CollectionEntryEventData, type CollectionEventData, type CommentEventData, type CommerceEventData, type CommerceSubjectEventData, type ConnectorEventData, type CredentialEventData, type DataExportEventData, type DataschemaContext, type DealEventData, type EmployeeEventData, type EngagementEventData, type EventMap, type EventMapOf, type EventSink, type EventSpec, type Events, type FlagEventData, type FormEventData, type FormSubmissionEventData, type ForwardBlockOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InboxEventData, type IncomingWebhookEventData, type InvitationEventData, type InviteCodeEventData, type InvoiceEventData, type JobEventData, type LegalHoldEventData, type MergedEventMap, type NotificationDeliveryEventData, type NotificationEventData, type OrganizationDeletionEventData, type OrganizationDomainEventData, type OrganizationEventData, type PartyEventData, type PipelineEventData, type PipelineStageEventData, type PushDeviceEventData, type QuoteEventData, ROW_EVENT_TYPES, RowEventData, type SaasEventData, type SaasSubjectEventData, type SchedulingEventData, type ScimEventData, type SettingEventData, type SignatureEventData, type SlaEventData, type SsoProviderEventData, type StorageObjectEventData, type SubjectEventData, type SubjectEventType, type SupportEventData, type TemplateApplicationEventData, type TemplateEventData, type TimeEntryEventData, type TimesheetEventData, type WaitlistEventData, type WebhookEventData, type WorkItemEventData, type WorkflowEventData, type WorkflowRunEventData, blockCloudEvent, blockEventAttributes, defineEvents, emitBlockEvent, event, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, mergeEvents, onBlockEvent, toCloudEvents, toHttp };

package/dist/events/index.js

@@ -1,7 +1,8 @@
-import { s as nowInstant } from "../temporal-BJGitm-h.js";
-import { n as forwardBlockEvents, t as blockCloudEvent } from "../cloud-event-BnmD5fb9.js";
+import { s as nowInstant } from "../temporal-CB5Fpo5d.js";
+import { i as forwardBlockEvents, n as blockCloudEvent, r as dataschemaOf } from "../cloud-event-CTh9Sr5w.js";
 import { t as jsonReplacer } from "../json-CEnpTHlZ.js";
-import { a as onBlockEvent, n as BLOCK_EVENT_RENAMES, r as blockEventAttributes, t as BLOCK_ATTRIBUTES } from "../block-events-CrT8r7Fe.js";
+import { n as event, r as mergeEvents, t as defineEvents } from "../event-map-Dy2vKHai.js";
+import { a as emitBlockEvent, i as blockEventAttributes, n as BLOCK_EVENT_RENAMES, o as onBlockEvent, t as BLOCK_ATTRIBUTES } from "../block-events-DD9Q_NUz.js";
 //#region src/events/index.ts
 const ROW_EVENT_TYPES = {
 	insert: "dev.better-supabase.row.created",
@@ -12,9 +13,9 @@ const ROW_EVENT_TYPES = {
 };
 function subjectOf(meta, table, row) {
 	const key = meta?.tables[table]?.primaryKey;
-	if (!key || key.length === 0) return void 0;
+	if (!key || key.length === 0) return;
 	const values = key.map((column) => row[column]);
-	if (values.some((value) => value === void 0 || value === null)) return void 0;
+	if (values.some((value) => value === void 0 || value === null)) return;
 	return `${table}/${values.map((value) => encodeURIComponent(String(value))).join(",")}`;
 }
 /**
@@ -31,6 +32,10 @@ function toCloudEvents(notice, options) {
 	const tenant = notice.tenant ?? notice.context.tenant;
 	const rows = notice.rows.length > 0 ? notice.rows : notice.keys ?? [];
 	const actorId = notice.context.actor?.id;
+	const dataschema = dataschemaOf(options, {
+		type,
+		table: notice.table
+	});
 	return rows.map((row) => {
 		const subject = subjectOf(options.meta, notice.table, row);
 		return {
@@ -41,6 +46,7 @@ function toCloudEvents(notice, options) {
 			...subject ? { subject } : {},
 			time,
 			datacontenttype: "application/json",
+			...dataschema,
 			data: {
 				table: notice.table,
 				row,
@@ -131,7 +137,8 @@ async function fromHttp(request) {
 	if (!isCloudEvent(event)) throw new TypeError("Request is not a CloudEvent");
 	return [event];
 }
-/** POSTs events to `url`. Non-2xx responses reject. */
+const HTTP_SINK_TIMEOUT_MS = 1e4;
+/** POSTs events to `url`. Non-2xx responses and timeouts reject. */
 function httpSink(url, options = {}) {
 	const send = options.fetch ?? fetch;
 	return { async send(events) {
@@ -142,11 +149,12 @@ function httpSink(url, options = {}) {
 					...options.headers,
 					...message.headers
 				},
-				body: message.body
+				body: message.body,
+				signal: AbortSignal.timeout(options.timeoutMs ?? HTTP_SINK_TIMEOUT_MS)
 			});
 			if (!response.ok) throw new Error(`Event sink responded ${String(response.status)}`);
 		}
 	} };
 }
 //#endregion
-export { BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, ROW_EVENT_TYPES, blockCloudEvent, blockEventAttributes, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, onBlockEvent, toCloudEvents, toHttp };
+export { BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, ROW_EVENT_TYPES, blockCloudEvent, blockEventAttributes, defineEvents, emitBlockEvent, event, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, mergeEvents, onBlockEvent, toCloudEvents, toHttp };