better-supabase 0.7.1 → 0.9.0

package/dist/assistant-Bf2cA6RO.d.ts

@@ -0,0 +1,148 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { i as AiMessage } from "./message-B0fNJgq8.js";
+import { E as AiRunStatus, F as AiUserMessageTrigger, _ as AiModerationAction, i as AiChat, u as AiChatRecord } from "./ai-chat-3GBSlFR4.js";
+import { n as GatewayOptions } from "./gateway-options-ClvvfuuU.js";
+import { o as StreamStore } from "./store-B5qYKsTh.js";
+import { i as CostBackfillPayload, t as AiUsage } from "./gateway-Cup00l0w.js";
+import { LanguageModelUsage, ModelMessage, UIMessage, UIMessageChunk, UIMessageStreamOnEndCallback } from "ai";
+//#region src/ai-sdk/chat/assistant.d.ts
+/** Who asks, for one request. */
+interface AssistantContext {
+  /**
+   * The chat block for this request: the user's transport, and a service
+   * transport (`service`) for the writes only the server makes.
+   */
+  readonly chats: AiChat;
+  readonly userId: string;
+  readonly organizationId: string;
+  /**
+   * Keeps the function alive until the answer is stored, after the response
+   * is sent: `after` in Next.js, `ctx.waitUntil` on Workers and Vercel.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** What `run` gets to generate one answer. */
+interface AssistantRunArgs {
+  readonly chat: AiChatRecord;
+  /** The model the request may use, after the catalog check. */
+  readonly model: string;
+  readonly messages: ModelMessage[];
+  /** The history the model sees, as UI messages. */
+  readonly uiMessages: UIMessage[];
+  /** Aborted by `stop()`; pass it to `streamText` or `agent.stream`. */
+  readonly abortSignal: AbortSignal;
+  /** Spend attribution for the AI Gateway (`gatewayOptions`). */
+  readonly providerOptions: {
+    readonly gateway: GatewayOptions;
+  };
+  readonly context: AssistantContext;
+}
+/** The part of a `streamText` or `agent.stream` result the assistant reads. */
+interface AssistantRunResult {
+  toUIMessageStream(options: {
+    originalMessages: UIMessage[];
+    generateMessageId: () => string;
+    onEnd: UIMessageStreamOnEndCallback<UIMessage>;
+    onError?: (error: unknown) => string;
+  }): ReadableStream<UIMessageChunk>;
+  readonly totalUsage?: PromiseLike<LanguageModelUsage>;
+  readonly providerMetadata?: PromiseLike<unknown>;
+}
+/** The verdict of a moderation hook. */
+interface AssistantModeration {
+  readonly action: AiModerationAction;
+  readonly category: string;
+  readonly score?: number;
+}
+/** What `onFinish` gets once the answer is stored. */
+interface AssistantFinish {
+  readonly chat: AiChatRecord;
+  readonly message: UIMessage;
+  readonly status: AiRunStatus;
+  readonly model: string;
+  readonly usage: AiUsage | undefined;
+  readonly context: AssistantContext;
+}
+interface AssistantOptions {
+  /** Where the answer's stream is kept, so a reload resumes it. */
+  readonly streams: StreamStore;
+  /** Starts the generation: `agent.stream(...)` or `streamText(...)`. */
+  readonly run: (args: AssistantRunArgs) => AssistantRunResult | PromiseLike<AssistantRunResult>;
+  /** The model when neither the request nor the chat names an allowed one. */
+  readonly defaultModel: string;
+  /**
+   * The quota check before a generation (`usageQuota(usage, meter)`); an
+   * error answers 429.
+   */
+  readonly quota?: (organizationId: string) => Promise<DbError | undefined>;
+  /** Checks the user's message; `block` answers 403, others are recorded. */
+  readonly moderate?: (input: {
+    readonly message: AiMessage;
+    readonly chat: AiChatRecord;
+  }) => Promise<AssistantModeration | undefined>;
+  /** Called with the cost backfill payload when the gateway hasn't reported a cost yet. */
+  readonly enqueueCostBackfill?: (payload: CostBackfillPayload) => Promise<unknown>;
+  /** Called after the answer is stored, such as to record usage. */
+  readonly onFinish?: (finish: AssistantFinish) => void | Promise<void>;
+  /** What the stream is kept for: seconds or a Postgres interval. Defaults to one day. */
+  readonly streamTtl?: number | string;
+  /** The `feature` tag of the gateway options. Defaults to `chat`. */
+  readonly feature?: string;
+  /** Turns a stream error into the message the client sees. */
+  readonly onError?: (error: unknown) => string;
+  /** Makes message and stream ids. Defaults to `crypto.randomUUID()`. */
+  readonly generateId?: () => string;
+}
+/** The body `useAssistant` sends. */
+interface AssistantRequestBody {
+  /** The chat id; the client may make it, and the chat is created on first use. */
+  readonly id: string;
+  readonly message: UIMessage;
+  readonly trigger?: AiUserMessageTrigger;
+  /** For `regenerate-message`, the answer to write again. */
+  readonly messageId?: string;
+  readonly model?: string;
+}
+/** A checked and stored user turn, ready for a model: what `prepare` returns. */
+interface AssistantTurn {
+  readonly chat: AiChatRecord;
+  /** The model the request may use, after the catalog check. */
+  readonly model: string;
+  /** The stored user message, which the answer is saved under. */
+  readonly parentId: string;
+  /** The history the model sees, as UI messages. */
+  readonly uiMessages: UIMessage[];
+  readonly messages: ModelMessage[];
+  /** Spend attribution for the AI Gateway (`gatewayOptions`). */
+  readonly providerOptions: {
+    readonly gateway: GatewayOptions;
+  };
+}
+interface Assistant {
+  /** Stores the user's message, starts the answer and streams it (SSE). */
+  respond(request: Request, context: AssistantContext): Promise<Response>;
+  /**
+   * The checks and writes before a generation, without one: parses the
+   * body `useAssistant` sends, creates the chat on first use, picks the
+   * model, moderates, checks the quota, stores the user's message and loads
+   * the history. Returns a problem response when one of them fails.
+   */
+  prepare(body: unknown, context: AssistantContext): Promise<AssistantTurn | Response>;
+  /** The running answer of `chatId` from the start, or 204 when none runs. */
+  resume(chatId: string, context: AssistantContext, options?: {
+    readonly fromIdx?: number;
+    readonly signal?: AbortSignal;
+  }): Promise<Response>;
+  /** Asks the running answer to stop: 204 whether or not one runs, a problem when the user may not. */
+  stop(chatId: string, context: AssistantContext): Promise<Response>;
+}
+/**
+ * A chat route for the AI SDK on the `ai-chat` block: `respond` stores the
+ * user's message, picks an allowed model, checks the quota, claims the
+ * chat's answer, runs the model and streams it while keeping a copy in the
+ * stream store; the answer and its usage are stored when it ends, even
+ * after the client left. `resume` replays it after a reload, `stop` ends it.
+ */
+declare function createAssistant(options: AssistantOptions): Assistant;
+//#endregion
+export { AssistantOptions as a, AssistantRunResult as c, AssistantModeration as i, AssistantTurn as l, AssistantContext as n, AssistantRequestBody as o, AssistantFinish as r, AssistantRunArgs as s, Assistant as t, createAssistant as u };

package/dist/astro/index.d.ts

@@ -1,10 +1,10 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
-import { t as BetterSupabase } from "../define-CJJkkr1-.js";
-import { t as BetterServer } from "../server-Bh0EVSwU.js";
-import { j as StorageImageOptions } from "../index-D48jVS-N.js";
-import { a as AuthorizedContext, c as Unwrapped, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-CkNzZUqv.js";
-import { t as RefusalRedirects } from "../refusal-DhSU2Vvr.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-BmzgK32X.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-YfwpIE-d.js";
+import { t as BetterSupabase } from "../define-DxHHbNEb.js";
+import { j as StorageImageOptions } from "../index-Bvw9r94Q.js";
+import { t as BetterServer } from "../server-types-OohhIQb2.js";
+import { a as AuthorizedContext, c as Unwrapped, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-D5S7KNFe.js";
+import { t as RefusalRedirects } from "../refusal-oD3ISM9h.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-DG5Bv39u.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/astro/index.d.ts
 /** The part of Astro's `APIContext` (middleware, pages, endpoints, actions) the integration uses. */
@@ -67,7 +67,8 @@ export interface AstroImageTransform {
   };
   readonly width?: number | undefined;
   readonly height?: number | undefined;
-  readonly quality?: number | "low" | "mid" | "high" | "max" | undefined;
+  /** A number, or a preset: `low`, `mid`, `high` or `max`. Other strings use the default quality. */
+  readonly quality?: number | string | undefined;
 }
 /** An Astro external image service, typed structurally. */
 export interface AstroImageService {

package/dist/astro/index.js

@@ -1,10 +1,10 @@
-import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-iKgjHVPx.js";
-import { t as defaultExpose } from "../respond-BUgsXNgk.js";
-import { i as requireCaller, o as runAction } from "../kit-Fm-Fv7q5.js";
+import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-CEjmtazZ.js";
+import { t as defaultExpose } from "../respond-DdhZ9Wbn.js";
+import { i as requireCaller, o as runAction } from "../kit-MUK34-ZG.js";
 import { t as storageImageUrl } from "../image-url-pIVlO6R1.js";
-import { t as around } from "../shared-CBxosKK3.js";
-import { i as localsOf, r as frameworkEntry } from "../framework-a7aRCIqv.js";
-import { r as refusalResponse } from "../refusal-CeJWxmkH.js";
+import { t as around } from "../shared-BmMcMoW9.js";
+import { i as localsOf, r as frameworkEntry } from "../framework-INbjMZX1.js";
+import { r as refusalResponse } from "../refusal-br4Ma9Cf.js";
 //#region src/astro/index.ts
 function runtimeEnv(locals) {
 	const runtime = "runtime" in locals ? locals.runtime : void 0;
@@ -23,7 +23,7 @@ function createAstro(betterSupabase, options = {}) {
 		const scope = scopeOf(context);
 		return {
 			scope,
-			caller: await requireCaller(scope.bs.auth, requireOptions, scope.tenant)
+			caller: await requireCaller(scope.bs.auth, requireOptions, scope.tenant, options.authorizer)
 		};
 	};
 	return extendServer(server, {
@@ -57,7 +57,7 @@ function createAstro(betterSupabase, options = {}) {
 				return await runAction(scope.bs.auth, actionOptions, input, scope.tenant, (parsed, caller) => fn(parsed, {
 					...scope,
 					...caller
-				}));
+				}), options.authorizer);
 			};
 		}
 	});
@@ -68,6 +68,9 @@ const QUALITY_PRESETS = {
 	high: 80,
 	max: 100
 };
+function isQualityPreset(quality) {
+	return Object.hasOwn(QUALITY_PRESETS, quality);
+}
 /**
 * An external image service that renders public Storage objects through
 * Supabase image transformations; other sources pass through.
@@ -81,7 +84,7 @@ function createImageService(options) {
 	return { getURL(transform) {
 		const src = typeof transform.src === "string" ? transform.src : transform.src.src;
 		if (transform.width === void 0) return src;
-		const quality = typeof transform.quality === "string" ? QUALITY_PRESETS[transform.quality] : transform.quality;
+		const quality = typeof transform.quality === "string" ? isQualityPreset(transform.quality) ? QUALITY_PRESETS[transform.quality] : void 0 : transform.quality;
 		return imageUrl(src, {
 			width: transform.width,
 			height: transform.height,

package/dist/asyncapi/index.d.ts

@@ -0,0 +1,103 @@
+import { c as SpecDiagnostic, r as DocumentFormat } from "../format-CNwSjXUU.js";
+import { C as ApiSource, F as EventsOptions, I as TopicInput, L as topicsFrom, M as BlockEventSchemas, N as CLOUD_EVENT_TRAIT, P as CloudEventsInput, j as BlockEventSchema, n as DefineApiOptions } from "../api-TG3jE5aO.js";
+import { t as SPEC_PINS } from "../spec-pins-Dqpml2dZ.js";
+//#region src/asyncapi/types.d.ts
+type Json = Record<string, unknown>;
+/** The AsyncAPI versions `asyncapiFormat` renders. */
+type AsyncApiVersion = "3.0" | "3.1";
+/** The file name `asyncapiFormat` writes; Arazzo source descriptions point at it. */
+export declare const ASYNCAPI_FILE_NAME = "asyncapi.json";
+interface AsyncApiInfo {
+  readonly title: string;
+  readonly version: string;
+  readonly description?: string;
+  readonly termsOfService?: string;
+  readonly contact?: {
+    readonly name?: string;
+    readonly url?: string;
+    readonly email?: string;
+  };
+  readonly license?: {
+    readonly name: string;
+    readonly url?: string;
+  };
+}
+interface AsyncApiComponents {
+  readonly schemas?: Readonly<Record<string, Json>>;
+  readonly messages?: Readonly<Record<string, Json>>;
+  readonly messageTraits?: Readonly<Record<string, Json>>;
+  readonly securitySchemes?: Readonly<Record<string, Json>>;
+}
+interface AsyncApiDocumentBase {
+  readonly info: AsyncApiInfo;
+  readonly defaultContentType: string;
+  readonly servers?: Readonly<Record<string, Json>>;
+  /** Channel id to Channel Object. */
+  readonly channels: Readonly<Record<string, Json>>;
+  /** Operation id to Operation Object. */
+  readonly operations: Readonly<Record<string, Json>>;
+  readonly components: AsyncApiComponents;
+  readonly [extension: `x-${string}`]: unknown;
+}
+interface AsyncApi30Document extends AsyncApiDocumentBase {
+  readonly asyncapi: typeof SPEC_PINS.asyncapi30;
+}
+/** AsyncAPI 3.1 adds the `ros2` bindings; the rest matches 3.0. */
+interface AsyncApi31Document extends AsyncApiDocumentBase {
+  readonly asyncapi: typeof SPEC_PINS.asyncapi31;
+}
+interface AsyncApiDocuments {
+  readonly "3.0": AsyncApi30Document;
+  readonly "3.1": AsyncApi31Document;
+}
+type AsyncApiDocument<V extends AsyncApiVersion = "3.0"> = AsyncApiDocuments[V];
+type AnyAsyncApiDocument = AsyncApiDocuments[AsyncApiVersion];
+/** What an AsyncAPI `transform` receives, discriminated by `version`. */
+type RenderedAsyncApi = { readonly [V in AsyncApiVersion]: {
+  readonly format: "asyncapi";
+  readonly version: V;
+  readonly document: AsyncApiDocuments[V];
+}; }[AsyncApiVersion];
+//#endregion
+//#region src/asyncapi/format.d.ts
+/**
+ * AsyncAPI as a `DocumentFormat`, for the events the API model describes:
+ * Realtime table change signals and broadcast topics on the Supabase
+ * Realtime websocket (`ws` bindings), CloudEvents (headers as the
+ * `cloudEvent` message trait), outgoing webhooks over HTTP and the events
+ * HTTP operations emit. 3.0 is the default; 3.1 only adds `ros2` bindings,
+ * so the two documents differ in the `asyncapi` field.
+ */
+export declare const asyncapiFormat: DocumentFormat<"asyncapi", AsyncApiVersion, AnyAsyncApiDocument, AsyncApiDocuments>;
+//#endregion
+//#region src/asyncapi/index.d.ts
+export interface AsyncApiOptions<V extends AsyncApiVersion = "3.0", Ref = string> extends DefineApiOptions<Ref> {
+  /** Defaults to 3.0, which more tools read; 3.1 only adds `ros2` bindings. */
+  readonly version?: V;
+  /** Last change to the document before overlays; it receives a copy. */
+  readonly transform?: (rendered: Extract<RenderedAsyncApi, {
+    readonly version: V;
+  }>) => AnyAsyncApiDocument | undefined;
+  readonly overlays?: readonly unknown[];
+  /** Hears every warning and info finding. Errors throw. */
+  readonly onDiagnostic?: (diagnostic: SpecDiagnostic) => void;
+}
+/**
+ * An AsyncAPI document for the app's events: Realtime table change signals
+ * and broadcast topics, CloudEvents for row and block events, outgoing
+ * webhooks and the events HTTP operations emit. Pass `events` (and
+ * `realtimeUrl` for the websocket server). Throws when building or checking
+ * the document finds an error; use `defineApi(...).render(asyncapiFormat)`
+ * to read every finding instead.
+ *
+ * ```ts
+ * const doc = createAsyncApi(betterSupabase, {
+ *   info: { title: "CRM events", version: "1.0.0" },
+ *   realtimeUrl: "wss://example.supabase.co/realtime/v1/websocket",
+ *   events: { tables: ["customers"], cloudEvents: { source: "/crm", blocks: { "support.started": true } } },
+ * });
+ * ```
+ */
+export declare function createAsyncApi<V extends AsyncApiVersion = "3.0", Ref = string>(betterSupabase: ApiSource, options: AsyncApiOptions<V, Ref>): AsyncApiDocuments[V];
+//#endregion
+export { type AnyAsyncApiDocument, type AsyncApi30Document, type AsyncApi31Document, type AsyncApiComponents, type AsyncApiDocument, type AsyncApiDocuments, type AsyncApiInfo, type AsyncApiVersion, type BlockEventSchema, type BlockEventSchemas, CLOUD_EVENT_TRAIT, type CloudEventsInput, type EventsOptions, type RenderedAsyncApi, type TopicInput, topicsFrom };