better-supabase 0.17.0 → 0.18.0

package/dist/orpc/index.d.ts

@@ -4,12 +4,12 @@ import { r as AuthState } from "../resolve-CXX6DHv3.js";
 import { i as ProblemDetails } from "../problem-DNwN8iGz.js";
 import { t as BetterSupabase } from "../define-Cgru0_kF.js";
 import { a as ServerContext, c as ServerOptions, n as BetterServer } from "../server-types-gR4Q1aM0.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-Dn1_YhC1.js";
-import { c as ResourceLoaderContext, i as AuthorizeOptions } from "../kit-DOwKpSkA.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-oZeJ342J.js";
+import { c as ResourceLoaderContext, i as AuthorizeOptions } from "../kit-CVgQCIBO.js";
 import { t as Validated } from "../shared-CRRfQAKG.js";
-import { a as ResourceHandler } from "../resource-types-BIoz_ElD.js";
+import { a as ResourceHandler } from "../resource-types-8Q5Klkpa.js";
 import { i as RouteRateLimitRule, n as RateLimitVerdict, r as RateLimiter, t as RateLimitRouteOptions } from "../rate-limit-Bztf32cl.js";
-import { t as Api } from "../api-CpL3hm87.js";
+import { t as Api } from "../api-B6zteBya.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { AnySchema, BuilderWithMiddlewares, DecoratedMiddleware, DecoratedProcedure, MetaPlugin, ORPCError, Schema } from "@orpc/server";
 //#region src/orpc/router.d.ts
@@ -88,10 +88,17 @@ export declare function toOrpc<const Entries extends readonly AnyEntry[]>(entrie
 } & Contributions<Entries>>, options?: ToOrpcOptions): (request: Request, env?: unknown) => Promise<Response>;
 //#endregion
 //#region src/orpc/index.d.ts
-/** Initial context: pass `{ context: { request } }` to the oRPC handler. */
-export interface OrpcRequestContext {
+/**
+ * Initial context: pass `{ context: { request } }` to the oRPC handler, or `{
+ * context: { headers } }` from an adapter that has no `Request` (the Node
+ * handler, a WebSocket peer). `url` defaults to `http://localhost/`.
+ */
+export type OrpcRequestContext = {
   readonly request: Request;
-}
+} | {
+  readonly headers: Headers;
+  readonly url?: string;
+};
 /** What `middleware()` adds to `context`. */
 export interface OrpcContext<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> {
   readonly bsb: ServerContext<M, F, E, C, P, B>;
@@ -125,10 +132,14 @@ export interface OrpcFetchOptions {
   readonly prefix?: `/${string}`;
 }
 export type OrpcMiddleware<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = DecoratedMiddleware<OrpcRequestContext, OrpcContext<M, F, E, C, P, B>, unknown, any, Record<never, never>>;
-/** What a `rateLimit()` key function reads: the procedure's context and path. */
+/**
+ * What a `rateLimit()` key function reads: the procedure's context, its path
+ * and the request (built from `context.headers` when the context has none).
+ */
 export interface OrpcRateLimitInput<TContext extends OrpcRequestContext> {
   readonly context: TContext;
   readonly path: readonly string[];
+  readonly request: Request;
 }
 /** The middleware `rateLimit()` returns; it adds nothing to `context`. */
 export type OrpcRateLimitMiddleware<TContext extends OrpcRequestContext> = DecoratedMiddleware<TContext, Record<never, never>, unknown, any, Record<never, never>>;

package/dist/orpc/index.js

@@ -6,13 +6,13 @@ import { c as toProblem } from "../problem-Bf0cJ7tk.js";
 import { i as claimsOf } from "../claims-Bp9My7XP.js";
 import { t as callWithInput } from "../block-method-C9hWdHom.js";
 import { t as tenantOf } from "../tenant-BgIiMQpo.js";
-import { c as extendServer, n as flushEvents, s as createServer, x as refreshFor } from "../adapter-Dyks1lX1.js";
+import { c as extendServer, n as flushEvents, s as createServer, x as refreshFor } from "../adapter-CfuBICuG.js";
 import { r as checkPermission } from "../authorizer-BGhXaDmo.js";
 import { n as toSession } from "../view-C8Ve14ja.js";
-import { o as settle, r as guard, t as defaultExpose } from "../respond-C3CcOZlA.js";
+import { i as guard, n as defaultExpose, s as settle, t as assertCookieRefresh } from "../respond-3RKp6VgU.js";
 import { t as TABLE_VERBS } from "../resource-DvgXqZB_.js";
-import { r as contextOf, t as defineResource } from "../resource-DV2GC2dB.js";
-import { t as authorizeCaller } from "../kit-5l-o8RxL.js";
+import { r as contextOf, t as defineResource } from "../resource-R3KToNze.js";
+import { t as authorizeCaller } from "../kit-DhlB-vv_.js";
 import { t as rateLimitGate } from "../rate-limit-BWKGlhTM.js";
 import { bufferRequest, pipeline, seedContext } from "@supabase/middleware";
 import { COMMON_ERROR_STATUS_MAP, ORPCError, os } from "@orpc/server";
@@ -194,6 +194,22 @@ function withHeaders(response, headers) {
 	for (const [name, value] of headers) copy.headers.set(name, value);
 	return copy;
 }
+const built = /* @__PURE__ */ new WeakMap();
+/**
+* A `Request` carrying `headers`, built once per `Headers` object so nested
+* middleware share the per-request cache.
+*/
+function requestFromHeaders(headers, url = "http://localhost/") {
+	const known = built.get(headers);
+	if (known) return known;
+	const request = new Request(url, { headers });
+	built.set(headers, request);
+	return request;
+}
+/** The context's request, built from its headers when it has none. */
+function requestOf(context) {
+	return "request" in context ? context.request : requestFromHeaders(context.headers, context.url);
+}
 /** ORPC integration: middleware adding the caller's repositories to `context`. */
 function createOrpc(betterSupabase, options = {}) {
 	const server = createServer(betterSupabase, options);
@@ -208,44 +224,57 @@ function createOrpc(betterSupabase, options = {}) {
 			data: problem
 		});
 	};
-	const middleware = (middlewareOptions = {}) => os.$context().middleware(async ({ context, next }, input) => {
-		const refresh = refreshFor(middlewareOptions.refresh, context.request) ?? false;
-		const known = contexts.get(context.request);
-		const ctx = known && (known.refresh || !refresh) ? known.ctx : await server.context(context.request, { refresh });
-		contexts.set(context.request, {
-			ctx,
-			refresh: refresh || (known?.refresh ?? false)
+	const middleware = (middlewareOptions = {}) => {
+		assertCookieRefresh(middlewareOptions);
+		const cookies = middlewareOptions.cookies;
+		return os.$context().middleware(async ({ context, next }, input) => {
+			const request = requestOf(context);
+			const refresh = refreshFor(middlewareOptions.refresh, request) ?? false;
+			const readsCookies = cookies !== false;
+			const known = contexts.get(request);
+			const reuse = known?.cookies === readsCookies && (known.refresh || !refresh);
+			const ctx = reuse ? known.ctx : await server.context(request, {
+				refresh,
+				cookies: readsCookies
+			});
+			contexts.set(request, {
+				ctx,
+				refresh: reuse ? known.refresh || refresh : refresh,
+				cookies: readsCookies
+			});
+			const denied = guard(ctx.auth, middlewareOptions.allow, middlewareOptions.aal, middlewareOptions.scopes);
+			if (denied) throw toOrpcError(denied);
+			const caller = await authorizeCaller(ctx.auth, middlewareOptions, input, tenantOf(toSession(ctx.auth), tenantClaim), options.authorizer, ctx);
+			if ("kind" in caller) throw toOrpcError(caller);
+			try {
+				return await next({ context: {
+					bsb: ctx,
+					db: ctx.db,
+					auth: ctx.auth
+				} });
+			} catch (cause) {
+				const thrown = dbErrorOf(cause);
+				if (thrown) throw toOrpcError(thrown);
+				throw cause;
+			}
 		});
-		const denied = guard(ctx.auth, middlewareOptions.allow, middlewareOptions.aal, middlewareOptions.scopes);
-		if (denied) throw toOrpcError(denied);
-		const caller = await authorizeCaller(ctx.auth, middlewareOptions, input, tenantOf(toSession(ctx.auth), tenantClaim), options.authorizer, ctx);
-		if ("kind" in caller) throw toOrpcError(caller);
-		try {
-			return await next({ context: {
-				bsb: ctx,
-				db: ctx.db,
-				auth: ctx.auth
-			} });
-		} catch (cause) {
-			const thrown = dbErrorOf(cause);
-			if (thrown) throw toOrpcError(thrown);
-			throw cause;
-		}
-	});
+	};
 	return extendServer(server, {
 		toOrpcError,
 		middleware,
 		rateLimit(rateLimitOptions) {
 			const gate = rateLimitGate(rateLimitOptions);
 			return os.$context().middleware(async ({ context, path, next }) => {
+				const request = requestOf(context);
 				const outcome = await gate({
 					context,
-					path
+					path,
+					request
 				});
 				if (outcome.kind === "skip") return next();
-				const kept = limits.get(context.request) ?? new Headers();
+				const kept = limits.get(request) ?? new Headers();
 				for (const [name, value] of outcome.headers) kept.set(name, value);
-				limits.set(context.request, kept);
+				limits.set(request, kept);
 				if (outcome.kind === "deny") throw toOrpcError(outcome.error);
 				return next();
 			});
@@ -285,7 +314,7 @@ function createOrpc(betterSupabase, options = {}) {
 					const settled = await settle(() => run({
 						input,
 						db: context.db,
-						request: context.request
+						request: requestOf(context)
 					}));
 					if (!settled.ok) throw toOrpcError(settled.error);
 					return settled.data;

package/dist/otel/index.d.ts

@@ -1,6 +1,6 @@
 import { Mt as Plugin } from "../types-DFdg_4yN.js";
 import { o as EventHub } from "../events-vcqenSYU.js";
-import { t as SPEC_PINS } from "../spec-pins-DIx95afw.js";
+import { t as SPEC_PINS } from "../spec-pins-BZkKfwY8.js";
 import { Attributes, Meter, Tracer } from "@opentelemetry/api";
 //#region src/otel/index.d.ts
 export declare const INSTRUMENTATION_NAME = "better-supabase";

package/dist/otel/index.js

@@ -1,5 +1,5 @@
 import { r as definePlugin } from "../plugin-AKwwe2gF.js";
-import { t as SPEC_PINS } from "../spec-pins-C1Vm8OBl.js";
+import { t as SPEC_PINS } from "../spec-pins-D3zDek-u.js";
 import { i as blockEventAttributes } from "../block-events-pBXPzwnW.js";
 import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 //#endregion
@@ -40,9 +40,9 @@ function systemOf(executor) {
 * ```
 */
 function otel(options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.17.0");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.18.0");
 	let histogram;
-	if (options.metrics !== false) histogram = (options.meter ?? metrics.getMeter("better-supabase", "0.17.0")).createHistogram("db.client.operation.duration", {
+	if (options.metrics !== false) histogram = (options.meter ?? metrics.getMeter("better-supabase", "0.18.0")).createHistogram("db.client.operation.duration", {
 		unit: "s",
 		description: "Duration of database client operations.",
 		advice: { explicitBucketBoundaries: [
@@ -219,7 +219,7 @@ function otel(options = {}) {
 * `betterSupabase.events`. Returns a function that stops listening.
 */
 function traceAuth(betterSupabase, options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.17.0");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.18.0");
 	const offAuth = betterSupabase.events.on("auth", (event) => {
 		const span = tracer.startSpan("auth.resolve", {
 			kind: SpanKind.INTERNAL,
@@ -257,7 +257,7 @@ function traceAuth(betterSupabase, options = {}) {
 * an error status. Returns a function that stops listening.
 */
 function traceBlockEvents(betterSupabase, options = {}) {
-	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.17.0");
+	const tracer = options.tracer ?? trace.getTracer("better-supabase", "0.18.0");
 	return betterSupabase.events.on("block", (event) => {
 		const attributes = {
 			...options.attributes,

package/dist/{ports-DnpAuTvB.d.ts → ports-g0H1Kzwr.d.ts}

@@ -1,5 +1,5 @@
 import { t as AsyncResult } from "./result-DZeA5KS6.js";
-import { n as TopicPort } from "./watch-topic-tnfOTa3-.js";
+import { n as TopicPort } from "./watch-topic-UGSEWAqR.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 //#region src/client/ports.d.ts
 /**

package/dist/powersync/index.d.ts

@@ -1,6 +1,9 @@
+import { f as Result } from "../result-DZeA5KS6.js";
 import { Bt as Executor } from "../types-DFdg_4yN.js";
+import { t as BlockTransport } from "../block-transport-DWZSJrwN.js";
 import { C as UploadRouteOptions, E as uploadRoute, S as UploadRoute, T as uploadOutcome, _ as UploadConnectorOptions, b as UploadOutcome, c as LocalTablesOption, d as CreateUploadRepository, f as CrudEntryLike, g as UploadConnector, h as RejectedStore, m as RejectedChange, n as DataEngine, p as CrudQueueLike, s as LiveEngineOptions, v as UploadErrorContext, w as createUploadConnector, x as UploadRepository, y as UploadFunction } from "../data-engine-BWoz9lED.js";
-import { t as AuthSnapshot } from "../bind-C801IaK-.js";
+import { n as TopicPort } from "../watch-topic-UGSEWAqR.js";
+import { t as AuthSnapshot } from "../bind-pu5TLrla.js";
 import { C as quoteSqliteIdent, S as likeToGlob, _ as SqliteQuery, a as postgrestTimestamp, b as SqliteValue, c as sqliteCompiler, d as SqliteDecode, f as SqliteInsertPlan, g as SqlitePlan, h as SqliteNested, i as fromSqliteError, l as SqliteColumn, m as SqliteKeys, n as SqliteDatabaseLike, o as CheckSqliteOptions, p as SqliteKeyedPlan, r as SqliteExecutorOptions, s as checkSqlite, t as SqliteContextLike, u as SqliteCompilerOptions, v as SqliteReturning, w as sqliteValue, x as compileSqlite, y as SqliteSelectPlan } from "../executor-BWFfz0ik.js";
 //#region src/powersync/sync.d.ts
 /** The part of PowerSync's `SyncStatus` the engine reads. */
@@ -138,4 +141,134 @@ interface SyncWithAuthOptions<C> {
  */
 export declare function syncWithAuth<C>(db: SyncedDatabaseLike<C>, auth: AuthSourceLike, options: SyncWithAuthOptions<C>): () => void;
 //#endregion
-export { type AuthSourceLike, type CheckSqliteOptions, type CreateUploadRepository, type CrudEntryLike, type CrudQueueLike, type PowerSyncDatabaseLike, type PowerSyncEngineOptions, type PowerSyncExecutorOptions, type RejectedChange, type RejectedStore, type SqliteColumn, type SqliteCompilerOptions, type SqliteContextLike, type SqliteDecode, type SqliteInsertPlan, type SqliteKeyedPlan, type SqliteKeys, type SqliteNested, type SqlitePlan, type SqliteQuery, type SqliteReturning, type SqliteSelectPlan, type SqliteValue, type SyncStatusLike, type SyncWithAuthOptions, type SyncedDatabaseLike, type UploadConnector, type UploadConnectorOptions, type UploadErrorContext, type UploadFunction, type UploadOutcome, type UploadRepository, type UploadRoute, type UploadRouteOptions, checkSqlite, compileSqlite, createUploadConnector, fromSqliteError, likeToGlob, postgrestTimestamp, quoteSqliteIdent, sqliteCompiler, sqliteValue, uploadOutcome, uploadRoute };
+//#region src/powersync/attachments.d.ts
+interface AttachmentQueueRouteOptions {
+  /**
+   * `blocks.attachments.options.path`, for `path()`. Default
+   * `{organization_id}/attachments/{id}`.
+   */
+  readonly path?: string;
+  /** `blocks.attachments.options.extraColumns` a `PUT` sends too. */
+  readonly extraColumns?: readonly string[];
+}
+/** The attachment columns `path()` reads, as PowerSync syncs them. */
+interface AttachmentPathRow {
+  readonly id: string;
+  readonly organization_id?: string | null;
+  readonly subject_type?: string | null;
+  readonly subject_id?: string | null;
+  readonly name?: string | null;
+  readonly version?: number | null;
+}
+/** An upload route for the attachments table, with the object path builder. */
+interface AttachmentQueueRoute extends UploadFunction {
+  /**
+   * The object path of the row's current version, the same as the database's
+   * `object_path`: give it to PowerSync's `AttachmentQueue` as the file's
+   * storage path.
+   */
+  path(row: AttachmentPathRow): string;
+}
+/**
+ * Replays the attachments table for `createUploadConnector`, with
+ * `blocks.attachments.options.offline` on: a `PUT` inserts the record under the
+ * id the client chose, counting a `conflict` as applied, and a `DELETE` removes
+ * the record first, which queues its files for deletion. A `PATCH` fails with
+ * `unsupported`. Upload the file to `route.path(row)`; the storage trigger
+ * marks the record uploaded.
+ *
+ * ```ts
+ * const attachments = attachmentQueueRoute(server.db.attachments);
+ * tables: { attachments },
+ * ```
+ */
+export declare function attachmentQueueRoute(repository: CreateUploadRepository<never, never>, options?: AttachmentQueueRouteOptions): AttachmentQueueRoute;
+//#endregion
+//#region src/powersync/notifications.d.ts
+/** The notification functions the local transport answers from SQLite. */
+type LocalNotificationFunction = "get_notification" | "list_notifications" | "notification_page" | "notification_counts" | "mark_notifications_read" | "mark_notifications_unread" | "dismiss_notifications";
+interface PowerSyncNotificationsOptions {
+  /**
+   * Where every other function goes, and every call when `local` is `false`:
+   * `rpcTransport(supabase)`.
+   */
+  readonly server: BlockTransport;
+  /**
+   * The synced table names, as `powersync streams` wrote them into the client
+   * schema. Default `notification_recipients` and `notification_events`.
+   */
+  readonly tables?: {
+    readonly recipients?: string;
+    readonly events?: string;
+  };
+  /**
+   * The tenant column, when `config.tenancy` renames it. Default
+   * `organization_id`.
+   */
+  readonly tenantColumn?: string;
+  /** Function names, when the instance renames them (`blocks.<name>.entities`). */
+  readonly functions?: Partial<Record<LocalNotificationFunction, string>>;
+}
+/**
+ * A block transport for the notifications module on PowerSync: the feed, its
+ * counts and marking read, unread or dismissed run on the synced tables, so the
+ * inbox works offline. Writes go into PowerSync's upload queue, which
+ * `notificationRecipientsRoute` replays on the server. Every other function
+ * (sending, preferences, resolving) goes to `server`.
+ *
+ * ```ts
+ * const notifications = createNotifications({
+ *   transport: powersyncNotificationsTransport(powersync, {
+ *     server: rpcTransport(supabase),
+ *   }),
+ * });
+ * ```
+ *
+ * The synced rows are the signed-in user's only (the `powersync streams` query
+ * filters by `auth.user_id()`), so the local reads add no user filter.
+ */
+export declare function powersyncNotificationsTransport(database: PowerSyncDatabaseLike, options: PowerSyncNotificationsOptions): BlockTransport;
+/**
+ * The upload route's notifications client: the server one, not the local
+ * transport.
+ */
+interface NotificationRecipientWrites {
+  markRead(options: {
+    readonly ids: readonly string[];
+  }): PromiseLike<Result<unknown>>;
+  markUnread(options: {
+    readonly ids: readonly string[];
+  }): PromiseLike<Result<unknown>>;
+  dismiss(ids: readonly string[]): PromiseLike<Result<unknown>>;
+}
+/**
+ * The upload route for `notification_recipients`: replays a local mark read,
+ * unread or dismiss through the server's functions, which check the caller owns
+ * the row. Pass a notifications client on `rpcTransport(supabase)`; one on
+ * `powersyncNotificationsTransport` would write the change locally again.
+ *
+ * ```ts
+ * createUploadConnector({
+ *   routes: {
+ *     notification_recipients: notificationRecipientsRoute(
+ *       serverNotifications,
+ *     ),
+ *   },
+ * });
+ * ```
+ */
+export declare function notificationRecipientsRoute(notifications: NotificationRecipientWrites): UploadFunction;
+/**
+ * A topic port for the notifications feed on PowerSync: the feed reads again
+ * when the synced notification tables change, from a sync or a local write,
+ * instead of on a Realtime broadcast.
+ *
+ * ```ts
+ * createNotificationsController({
+ *   ports: { topic: powersyncTopicPort(powersync) },
+ * });
+ * ```
+ */
+export declare function powersyncTopicPort(database: PowerSyncDatabaseLike, tables?: readonly string[]): TopicPort;
+//#endregion
+export { type AttachmentPathRow, type AttachmentQueueRoute, type AttachmentQueueRouteOptions, type AuthSourceLike, type CheckSqliteOptions, type CreateUploadRepository, type CrudEntryLike, type CrudQueueLike, type LocalNotificationFunction, type NotificationRecipientWrites, type PowerSyncDatabaseLike, type PowerSyncEngineOptions, type PowerSyncExecutorOptions, type PowerSyncNotificationsOptions, type RejectedChange, type RejectedStore, type SqliteColumn, type SqliteCompilerOptions, type SqliteContextLike, type SqliteDecode, type SqliteInsertPlan, type SqliteKeyedPlan, type SqliteKeys, type SqliteNested, type SqlitePlan, type SqliteQuery, type SqliteReturning, type SqliteSelectPlan, type SqliteValue, type SyncStatusLike, type SyncWithAuthOptions, type SyncedDatabaseLike, type UploadConnector, type UploadConnectorOptions, type UploadErrorContext, type UploadFunction, type UploadOutcome, type UploadRepository, type UploadRoute, type UploadRouteOptions, checkSqlite, compileSqlite, createUploadConnector, fromSqliteError, likeToGlob, postgrestTimestamp, quoteSqliteIdent, sqliteCompiler, sqliteValue, uploadOutcome, uploadRoute };