better-supabase 0.11.0 → 0.13.0

package/dist/tags-Co-QIHeK.js

@@ -0,0 +1,84 @@
+import { t as AsyncResult } from "./result-DIT_qp4G.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { C as optionalText, D as recordOf, I as textOf, n as applyTemporal, o as blockCall } from "./block-helpers-DwE32_gT.js";
+import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
+import { n as blockFields } from "./block-fields-Cwd4c8m-.js";
+import { t as rankBetweenResult } from "./rank-result-C6vsw27N.js";
+//#region src/blocks/tags/tags.ts
+function tagOf(value) {
+	const row = recordOf(value, "tag");
+	const optional = (key) => {
+		const found = optionalText(row[key]);
+		return found === void 0 ? {} : { [key]: found };
+	};
+	return {
+		id: textOf(row["id"]),
+		name: optionalText(row["name"]) ?? "",
+		slug: optionalText(row["slug"]) ?? "",
+		...optional("rank"),
+		...optional("kind"),
+		...optional("color"),
+		...optional("description"),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	};
+}
+const tagsOf = (value) => (Array.isArray(value) ? value : []).map(tagOf);
+/** The `tags` SQL module as typed calls. */
+function createTags(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "tag fields");
+	return withBlockHooks({
+		create: (organizationId, kind, name, color, description, extra) => fields.args(extra).andThen((checked) => call("create_tag", {
+			tenant: organizationId,
+			kind,
+			name,
+			color: color ?? null,
+			description: description ?? null,
+			fields: checked
+		}, (value) => ({
+			...tagOf(value),
+			name
+		})).andThen(fields.row)),
+		update: (id, name, extra) => fields.args(extra).andThen((checked) => call("update_tag", {
+			tag_id: id,
+			name,
+			fields: checked
+		}, (value) => value === true)),
+		reorder: (id, neighbors) => {
+			const key = rankBetweenResult(neighbors);
+			if (!key.ok) return AsyncResult.err(key.error);
+			return call("rank_tag", {
+				tag_id: id,
+				rank: key.data
+			}, () => key.data);
+		},
+		delete: (id) => call("delete_tag", { tag_id: id }, (value) => value === true),
+		tag: (organizationId, subjectType, subjectId, tagId) => call("tag", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			tag_id: tagId
+		}, (value) => value === true),
+		untag: (organizationId, subjectType, subjectId, tagId) => call("untag", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId,
+			tag_id: tagId
+		}, (value) => value === true),
+		list: (organizationId, kind) => call("list_tags", {
+			tenant: organizationId,
+			kind: kind ?? null
+		}, tagsOf).andThen(fields.rows),
+		forSubject: (organizationId, subjectType, subjectId) => call("subject_tags", {
+			tenant: organizationId,
+			subject_type: subjectType,
+			subject_id: subjectId
+		}, tagsOf).andThen(fields.rows)
+	}, options.hooks, {
+		block: "tags",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+export { createTags as t };

package/dist/tags-tbiuHHMV.d.ts

@@ -0,0 +1,30 @@
+import { Ut as CacheAdapter, Wt as CacheTarget } from "./define-D0LSXmUP.js";
+//#region src/core/tags.d.ts
+interface TagOptions {
+  /** The tenant the read is scoped to; `"*"` is every tenant's reads. */
+  readonly tenant?: string;
+}
+/**
+ * `bs:<table>`, `bs:<table>:<id>`, or `bs:<table>@<tenant>` for a read scoped
+ * to one tenant. Mutations invalidate the table tag, the tag of their tenant
+ * (`bs:<table>@*` without one) and the tags of the changed rows.
+ */
+declare function tagFor(table: string, id?: string | number, options?: TagOptions): string;
+/**
+ * The tags a mutation invalidates: `bs:<table>` for every table in the target,
+ * the tenant's `bs:<table>@<tenant>` (every tenant's `bs:<table>@*` when the
+ * mutation has no tenant) and `bs:<table>:<id>` per changed row.
+ */
+declare function cacheTagsOf(target: CacheTarget): string[];
+/**
+ * A `CacheAdapter` for any tag-based cache: it hands `invalidate` the tags from
+ * `cacheTagsOf`, e.g. a CDN purge by tag, SvelteKit's `invalidate`, or a Redis
+ * set of keys per tag. Tag your reads with `tagFor`.
+ *
+ * ```ts
+ * betterSupabase.cache(tagCache((tags) => purgeCdn(tags), "cdn"));
+ * ```
+ */
+declare function tagCache(invalidate: (tags: readonly string[]) => void | Promise<void>, name?: string): CacheAdapter;
+//#endregion
+export { tagFor as i, cacheTagsOf as n, tagCache as r, TagOptions as t };

package/dist/tanstack-db/index.d.ts

@@ -1,9 +1,12 @@
-import { B as TableKey, a as AnyModels, i as AnyFunctions } from "../types-BrpW5ixT.js";
-import { _ as Db, t as BetterSupabase } from "../define-M_r1d2AT.js";
-import { t as BetterQueryMeta } from "../invalidate-BBqhpxyB.js";
+import { B as TableKey, a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
+import { o as Db, t as BetterSupabase } from "../define-D0LSXmUP.js";
+import { t as BetterQueryMeta } from "../invalidate-BLiBFbLy.js";
 import { QueryClient, SkipToken } from "@tanstack/query-core";
 //#region src/tanstack-db/collection.d.ts
-/** The query a collection loads: `queries.<table>.findMany(args)` from `better-supabase/query`. */
+/**
+ * The query a collection loads: `queries.<table>.findMany(args)` from
+ * `better-supabase/query`.
+ */
 interface CollectionQuery<Row> {
   readonly queryKey: readonly unknown[];
   readonly queryFn: ((context: {
@@ -17,7 +20,10 @@ interface PendingMutationLike<Row> {
   readonly modified: Row;
   readonly changes: Partial<Row>;
 }
-/** The handler argument TanStack DB passes to `onInsert`, `onUpdate` and `onDelete`. */
+/**
+ * The handler argument TanStack DB passes to `onInsert`, `onUpdate` and
+ * `onDelete`.
+ */
 interface MutationParamsLike<Row> {
   readonly transaction: {
     readonly mutations: readonly PendingMutationLike<Row>[];
@@ -48,12 +54,12 @@ interface CollectionConfig<Row> {
   readonly onDelete: CollectionMutationHandler<Row>;
 }
 /**
- * A TanStack DB query collection for one table: it loads the rows with
- * `query`, keys them by the table's primary key, and sends inserts, updates
- * and deletes through the table's repository, so RLS, hooks, events and
- * plugins apply. After a write the collection refetches its query; with
- * `invalidateOnMutation(betterSupabase, queryClient)`, every other query
- * that read the table refetches too.
+ * A TanStack DB query collection for one table: it loads the rows with `query`,
+ * keys them by the table's primary key, and sends inserts, updates and deletes
+ * through the table's repository, so RLS, hooks, events and plugins apply.
+ * After a write the collection refetches its query; with
+ * `invalidateOnMutation(betterSupabase, queryClient)`, every other query that
+ * read the table refetches too.
  *
  * ```ts
  * const customers = createCollection(

package/dist/tanstack-db/index.js

@@ -5,12 +5,12 @@ function field(row, name) {
 	return Object.getOwnPropertyDescriptor(row, name)?.value;
 }
 /**
-* A TanStack DB query collection for one table: it loads the rows with
-* `query`, keys them by the table's primary key, and sends inserts, updates
-* and deletes through the table's repository, so RLS, hooks, events and
-* plugins apply. After a write the collection refetches its query; with
-* `invalidateOnMutation(betterSupabase, queryClient)`, every other query
-* that read the table refetches too.
+* A TanStack DB query collection for one table: it loads the rows with `query`,
+* keys them by the table's primary key, and sends inserts, updates and deletes
+* through the table's repository, so RLS, hooks, events and plugins apply.
+* After a write the collection refetches its query; with
+* `invalidateOnMutation(betterSupabase, queryClient)`, every other query that
+* read the table refetches too.
 *
 * ```ts
 * const customers = createCollection(

package/dist/tanstack-db/supabase/index.d.ts

@@ -1,5 +1,5 @@
-import { B as TableKey, a as AnyModels, i as AnyFunctions } from "../../types-BrpW5ixT.js";
-import { _ as Db, t as BetterSupabase } from "../../define-M_r1d2AT.js";
+import { B as TableKey, a as AnyModels, i as AnyFunctions } from "../../types-DmshMaXz.js";
+import { o as Db, t as BetterSupabase } from "../../define-D0LSXmUP.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { supabaseCollectionOptions } from "@supabase-labs/tanstack-db";
 import { StandardSchemaV1 } from "@standard-schema/spec";
@@ -7,26 +7,41 @@ import { QueryClient } from "@tanstack/query-core";
 //#region src/tanstack-db/supabase/collection.d.ts
 type LabsConfig<Schema extends StandardSchemaV1> = ReturnType<typeof supabaseCollectionOptions<Schema>>;
 /**
- * What `supabaseCollectionOptions()` from `@supabase-labs/tanstack-db`
- * returns, without `undefined` in its optional properties, so `createCollection()`
+ * What `supabaseCollectionOptions()` from `@supabase-labs/tanstack-db` returns,
+ * without `undefined` in its optional properties, so `createCollection()`
  * accepts it under `exactOptionalPropertyTypes`.
  */
 type SupabaseCollectionConfig<Schema extends StandardSchemaV1> = { [K in keyof LabsConfig<Schema>]: Exclude<LabsConfig<Schema>[K], undefined>; };
 interface BaseOptions<Schema extends StandardSchemaV1> {
-  /** The row schema, in the configured casing: `customersRow` from `standardSchema()`, `zod()` or `valibot()`. */
+  /**
+   * The row schema, in the configured casing: `customersRow` from
+   * `standardSchema()`, `zod()` or `valibot()`.
+   */
   readonly schema: Schema;
-  /** Applies inserts, updates and deletes from other clients through Realtime `postgres_changes`. */
+  /**
+   * Applies inserts, updates and deletes from other clients through Realtime
+   * `postgres_changes`.
+   */
   readonly realtime?: boolean;
-  /** Pushes each live query's filter to the Realtime subscription. Defaults to `false`. */
+  /**
+   * Pushes each live query's filter to the Realtime subscription. Defaults to
+   * `false`.
+   */
   readonly realtimeUseFilter?: boolean;
   readonly queryClient?: QueryClient;
 }
 type SupabaseCollectionOptions<M extends AnyModels, F extends AnyFunctions, E, Schema extends StandardSchemaV1> = BaseOptions<Schema> & ({
-  /** Sends writes through the table's repository (the default), so RLS, hooks, events and plugins apply. */
+  /**
+   * Sends writes through the table's repository (the default), so RLS,
+   * hooks, events and plugins apply.
+   */
   readonly writes?: "repository";
   readonly db: Db<M, F, E, unknown> | (() => Db<M, F, E, unknown>);
 } | {
-  /** Sends writes straight to PostgREST with the supabase client, like `@supabase-labs/tanstack-db`. */
+  /**
+   * Sends writes straight to PostgREST with the supabase client, like
+   * `@supabase-labs/tanstack-db`.
+   */
   readonly writes: "direct";
   readonly db?: never;
 });

package/dist/tanstack-db/supabase/index.js

@@ -34,7 +34,10 @@ function valueEnd(text, start) {
 	}
 	return index;
 }
-/** Renames the columns in a PostgREST logic tree: `(a.eq.1,and(b.gt.2,c.is.null))`. */
+/**
+* Renames the columns in a PostgREST logic tree:
+* `(a.eq.1,and(b.gt.2,c.is.null))`.
+*/
 function renameLogic(text, rename) {
 	let out = "";
 	let index = 0;
@@ -120,8 +123,8 @@ function bound(target, prop) {
 }
 /**
 * The client `@supabase-labs/tanstack-db` sees for one table: requests and
-* Realtime listeners run in the table's schema, and when app names differ
-* from column names, rows arrive in app names and leave in column names.
+* Realtime listeners run in the table's schema, and when app names differ from
+* column names, rows arrive in app names and leave in column names.
 */
 function tableClient(supabase, table) {
 	const toDb = /* @__PURE__ */ new Map();

package/dist/tanstack-start/index.d.ts

@@ -1,10 +1,10 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-BrpW5ixT.js";
-import { t as BetterSupabase } from "../define-M_r1d2AT.js";
-import { n as BetterServer } from "../server-types-BKN_R4Ws.js";
-import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-BeZX2pR_.js";
-import { t as RefusalRedirects } from "../refusal-CufncwaN.js";
-import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-D6IFkuAg.js";
-import { t as Validated } from "../shared-DDSjEGDR.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
+import { t as BetterSupabase } from "../define-D0LSXmUP.js";
+import { n as BetterServer } from "../server-types-D_cQ6OxZ.js";
+import { a as AuthorizedContext, c as ResourceLoaderContext, i as AuthorizeOptions, l as Unwrapped, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-LeQGMzLH.js";
+import { t as RefusalRedirects } from "../refusal-BEyNVFy7.js";
+import { n as FrameworkOptions, r as LocalsResource, t as FrameworkLocals } from "../framework-CMeAuJts.js";
+import { t as Validated } from "../shared-CRRfQAKG.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/bridges/tanstack-start.d.ts
@@ -21,15 +21,20 @@ interface ToTanStackStartOptions {
 }
 /**
  * Runs an entry array as the `.server()` callback of a TanStack Start
- * middleware. Every contributed key lands on `context`. On request
- * middleware the response passes back through the entries, so refreshed
- * session cookies reach it; on server function middleware the context still
- * flows, and a short circuit (a 401 from the guard) is thrown as a
- * `Response`, which TanStack Start sends.
+ * middleware. Every contributed key lands on `context`. On request middleware
+ * the response passes back through the entries, so refreshed session cookies
+ * reach it; on server function middleware the context still flows, and a short
+ * circuit (a 401 from the guard) is thrown as a `Response`, which TanStack
+ * Start sends.
  *
- * ```ts title="src/start.ts"
- * const supabase = createMiddleware().server(toTanStackStart([withBetterSupabase(server)]))
- * export const startInstance = createStart(() => ({ requestMiddleware: [supabase] }))
+ * ```ts
+ * // src/start.ts
+ * const supabase = createMiddleware().server(
+ *   toTanStackStart([withBetterSupabase(server)]),
+ * );
+ * export const startInstance = createStart(() => ({
+ *   requestMiddleware: [supabase],
+ * }));
  * ```
  */
 export declare function toTanStackStart<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, options?: ToTanStackStartOptions): <Result extends object>(args: TanStackStartServerArgs<Contributions<Entries>, Result>) => Promise<Result>;
@@ -47,29 +52,35 @@ interface TanStackStartHandlerArgs<Data, Context> {
 interface BetterTanStackStart<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> extends BetterServer<M, F, E, C, P, B> {
   /**
    * The `.server()` callback of a request middleware: verifies the caller,
-   * refreshes the session cookie on navigations and form posts, and puts
-   * `db`, `bs`, `auth`, `tenant` and the serializable `session` on `context`.
+   * refreshes the session cookie on navigations and form posts, and puts `db`,
+   * `bs`, `auth`, `tenant` and the serializable `session` on `context`.
    *
-   * ```ts title="src/start.ts"
-   * const supabase = createMiddleware().server(bs.middleware)
-   * export const startInstance = createStart(() => ({ requestMiddleware: [supabase] }))
+   * ```ts
+   * // src/start.ts
+   * const supabase = createMiddleware().server(bs.middleware);
+   * export const startInstance = createStart(() => ({
+   *   requestMiddleware: [supabase],
+   * }));
    * ```
    */
   readonly middleware: <Result extends object>(args: TanStackStartServerArgs<FrameworkLocals<M, F, E, C, P, B>, Result>) => Promise<Result>;
   /**
-   * The caller in a server function or route handler, or a thrown
-   * refusal: a redirect to `signIn` or `mfa` when configured, else a
-   * Problem Details response, which TanStack Start sends.
+   * The caller in a server function or route handler, or a thrown refusal: a
+   * redirect to `signIn` or `mfa` when configured, else a Problem Details
+   * response, which TanStack Start sends.
    */
-  require<R extends boolean = false>(context: FrameworkLocals<M, F, E, C, P, B>, options?: BlockRequireOptions<C, P, R>): Promise<FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>>;
+  require<R extends boolean = false>(context: FrameworkLocals<M, F, E, C, P, B>, options?: BlockRequireOptions<C, P, R, unknown, LocalsResource<M, F, E, C, P, B>>): Promise<FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>>;
   /**
    * A `createServerFn().handler()` returning an `ActionResult`, for
-   * `useAction`. Pass the same schema to `.inputValidator()` to type `data`
-   * on the client; `input` validates it again on the server.
+   * `useAction`. Pass the same schema to `.inputValidator()` to type `data` on
+   * the client; `input` validates it again on the server.
    */
-  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>) => T): <Data>(args: TanStackStartHandlerArgs<Data, FrameworkLocals<M, F, E, C, P, B>>) => Promise<ActionResult<Unwrapped<Awaited<T>>>>;
+  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R, unknown, LocalsResource<M, F, E, C, P, B>>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P, B> & AuthorizedContext<C, P, R>) => T): <Data>(args: TanStackStartHandlerArgs<Data, FrameworkLocals<M, F, E, C, P, B>>) => Promise<ActionResult<Unwrapped<Awaited<T>>>>;
 }
-/** TanStack Start integration: request middleware, guards and server function actions. */
+/**
+ * TanStack Start integration: request middleware, guards and server function
+ * actions.
+ */
 export declare function createTanStackStart<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P, B>, options?: TanStackStartOptions): BetterTanStackStart<M, F, E, C, P, B>;
 //#endregion
-export type { ActionResult, AuthorizeOptions, AuthorizedContext, BetterTanStackStart, BlockActionOptions, BlockRequireOptions, FrameworkLocals, FrameworkOptions, RefusalRedirects, TanStackStartHandlerArgs, TanStackStartOptions, TanStackStartServerArgs, ToTanStackStartOptions };
+export type { ActionResult, AuthorizeOptions, AuthorizedContext, BetterTanStackStart, BlockActionOptions, BlockRequireOptions, FrameworkLocals, FrameworkOptions, RefusalRedirects, ResourceLoaderContext, TanStackStartHandlerArgs, TanStackStartOptions, TanStackStartServerArgs, ToTanStackStartOptions };

package/dist/tanstack-start/index.js

@@ -1,31 +1,42 @@
-import { c as extendServer, o as withFlush, s as createServer } from "../adapter-B2WRsRIg.js";
-import { t as defaultExpose } from "../respond-Bhp3G__q.js";
-import { i as requireCaller, o as runAction } from "../kit-LTbHrWWD.js";
-import { n as bufferInPlace, t as around } from "../shared-BmMcMoW9.js";
-import { i as localsOf, r as frameworkEntry } from "../framework-Ch8bMmQY.js";
-import { r as refusalResponse } from "../refusal-CFpfmjcS.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-D8dW6p2A.js";
+import { t as defaultExpose } from "../respond-DjEmE_DN.js";
+import { i as requireCaller, o as runAction } from "../kit-BeXTrlZn.js";
+import { n as bufferInPlace, t as around } from "../shared-Bf-I13Ht.js";
+import { i as localsOf, r as frameworkEntry } from "../framework-BpEnOfAo.js";
+import { r as refusalResponse } from "../refusal-Ce2p81VW.js";
 //#region src/bridges/tanstack-start.ts
-/** The `response` of a request middleware's `next()` result; server function results have none. */
+/**
+* The `response` of a request middleware's `next()` result; server function
+* results have none.
+*/
 function responseOf(result) {
 	return "response" in result && result.response instanceof Response ? result.response : void 0;
 }
 /**
 * Runs an entry array as the `.server()` callback of a TanStack Start
-* middleware. Every contributed key lands on `context`. On request
-* middleware the response passes back through the entries, so refreshed
-* session cookies reach it; on server function middleware the context still
-* flows, and a short circuit (a 401 from the guard) is thrown as a
-* `Response`, which TanStack Start sends.
+* middleware. Every contributed key lands on `context`. On request middleware
+* the response passes back through the entries, so refreshed session cookies
+* reach it; on server function middleware the context still flows, and a short
+* circuit (a 401 from the guard) is thrown as a `Response`, which TanStack
+* Start sends.
 *
-* ```ts title="src/start.ts"
-* const supabase = createMiddleware().server(toTanStackStart([withBetterSupabase(server)]))
-* export const startInstance = createStart(() => ({ requestMiddleware: [supabase] }))
+* ```ts
+* // src/start.ts
+* const supabase = createMiddleware().server(
+*   toTanStackStart([withBetterSupabase(server)]),
+* );
+* export const startInstance = createStart(() => ({
+*   requestMiddleware: [supabase],
+* }));
 * ```
 */
 function toTanStackStart(entries, options = {}) {
 	return tanStackStartServer(around(entries), options.env, (contributions) => contributions);
 }
-/** The `.server()` callback over a folded pipeline, with the context `toContext` builds. */
+/**
+* The `.server()` callback over a folded pipeline, with the context `toContext`
+* builds.
+*/
 function tanStackStartServer(run, env, toContext) {
 	return async ({ request, next }) => {
 		bufferInPlace(request);
@@ -46,7 +57,10 @@ function tanStackStartServer(run, env, toContext) {
 }
 //#endregion
 //#region src/tanstack-start/create.ts
-/** TanStack Start integration: request middleware, guards and server function actions. */
+/**
+* TanStack Start integration: request middleware, guards and server function
+* actions.
+*/
 function createTanStackStart(betterSupabase, options = {}) {
 	const server = createServer(betterSupabase, options);
 	const expose = options.exposeErrors ?? defaultExpose();
@@ -66,7 +80,7 @@ function createTanStackStart(betterSupabase, options = {}) {
 		},
 		require: async (context, requireOptions = {}) => {
 			const scope = scopeOf(context);
-			const caller = await requireCaller(scope.bs.auth, requireOptions, scope.tenant, options.authorizer);
+			const caller = await requireCaller(scope.bs.auth, requireOptions, scope.tenant, options.authorizer, scope);
 			if ("kind" in caller) {
 				const request = requests.get(scope) ?? new Request("http://localhost/");
 				throw refusalResponse(caller, request, options, expose);
@@ -82,7 +96,7 @@ function createTanStackStart(betterSupabase, options = {}) {
 				return await runAction(scope.bs.auth, actionOptions, data, scope.tenant, (parsed, caller) => fn(parsed, {
 					...scope,
 					...caller
-				}), options.authorizer);
+				}), options.authorizer, scope);
 			};
 		}
 	});