dashboardLoader/Action can access the context data

Author: matt-aitken

apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.roles/route.tsx

@@ -56,8 +56,8 @@ export const loader = dashboardLoader(
     },
     authorization: { action: "read", resource: { type: "members" } },
   },
-  async ({ params }) => {
-    const orgId = await resolveOrgIdFromSlug(params.organizationSlug);
+  async ({ context }) => {
+    const orgId = context.organizationId;
     if (!orgId) {
       throw new Response("Not Found", { status: 404 });
     }

apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.team/route.tsx

@@ -99,8 +99,8 @@ export const loader = dashboardLoader(
     },
     authorization: { action: "read", resource: { type: "members" } },
   },
-  async ({ user, ability, params }) => {
-    const orgId = await resolveOrgIdFromSlug(params.organizationSlug);
+  async ({ user, ability, context }) => {
+    const orgId = context.organizationId;
     if (!orgId) {
       throw new Response("Not Found", { status: 404 });
     }
@@ -155,7 +155,7 @@ export const action = dashboardAction(
     // gated by the existing model layer; purchase-seats by the
     // SetSeatsAddOnService). Per-intent ability checks happen inside.
   },
-  async ({ user, ability, request, params }) => {
+  async ({ user, ability, request, params, context }) => {
     const userId = user.id;
     const { organizationSlug } = params;
     invariant(organizationSlug, "organizationSlug not found");
@@ -167,7 +167,7 @@ export const action = dashboardAction(
       if (!ability.can("manage", { type: "members" })) {
         return json({ ok: false, error: "Unauthorized" } as const, { status: 403 });
       }
-      const orgId = await resolveOrgIdFromSlug(organizationSlug);
+      const orgId = context.organizationId;
       if (!orgId) {
         return json({ ok: false, error: "Organization not found" } as const, { status: 404 });
       }

apps/webapp/app/services/routeBuilders/dashboardBuilder.server.ts

@@ -30,10 +30,16 @@ function isAuthorized(ability: RbacAbility, authorization: AuthorizationOption):
   return ability.can(authorization.action, authorization.resource);
 }
 
-export async function authenticateAndAuthorize<TParams, TSearchParams>(
+type AuthScope = { organizationId?: string; projectId?: string };
+
+export async function authenticateAndAuthorize<
+  TParams,
+  TSearchParams,
+  TContext extends AuthScope
+>(
   request: Request,
   rawParams: unknown,
-  options: DashboardLoaderOptions<TParams, TSearchParams>
+  options: DashboardLoaderOptions<TParams, TSearchParams, TContext>
 ): Promise<
   | { ok: false; response: Response }
   | {
@@ -42,6 +48,7 @@ export async function authenticateAndAuthorize<TParams, TSearchParams>(
       ability: RbacAbility;
       params: unknown;
       searchParams: unknown;
+      context: TContext;
     }
 > {
   let parsedParams: any = undefined;
@@ -75,7 +82,9 @@ export async function authenticateAndAuthorize<TParams, TSearchParams>(
     parsedSearchParams = parsed.data;
   }
 
-  const ctx = options.context ? await options.context(parsedParams, request) : {};
+  const ctx = (options.context
+    ? await options.context(parsedParams, request)
+    : ({} as TContext)) as TContext;
   const auth = await rbac.authenticateSession(request, ctx);
   if (!auth.ok) {
     if (auth.reason === "unauthenticated") {
@@ -94,5 +103,6 @@ export async function authenticateAndAuthorize<TParams, TSearchParams>(
     ability: auth.ability,
     params: parsedParams,
     searchParams: parsedSearchParams,
+    context: ctx,
   };
 }

apps/webapp/app/services/routeBuilders/dashboardBuilder.ts

@@ -43,19 +43,23 @@ export type AuthorizationOption =
       resource: RbacResource | RbacResource[];
     };
 
-export type DashboardLoaderOptions<TParams, TSearchParams> = {
+// Plugin-side scope: whatever the route's `context` returns must include
+// these (or just be `{}` when the route doesn't scope by org/project).
+// rbac.authenticateSession reads them off the value to filter UserRole.
+type AuthScope = { organizationId?: string; projectId?: string };
+
+export type DashboardLoaderOptions<TParams, TSearchParams, TContext extends AuthScope> = {
   params?: TParams;
   searchParams?: TSearchParams;
-  // Optional: provides organizationId / projectId to rbac.authenticateSession
-  // when the route's ability check needs it. The default fallback
-  // ignores context; an installed plugin may use it to scope the
-  // returned ability.
+  // Resolves any per-request data the handler + auth check both need
+  // (typically org/project lookups from URL params). The returned object
+  // is fed to `rbac.authenticateSession` as the auth scope AND passed
+  // through to the handler in `args.context`, so the route does each
+  // lookup once.
   context?: (
     params: InferZod<TParams>,
     request: Request
-  ) =>
-    | { organizationId?: string; projectId?: string }
-    | Promise<{ organizationId?: string; projectId?: string }>;
+  ) => TContext | Promise<TContext>;
   authorization?: AuthorizationOption;
   // Where to send unauthenticated requests. Defaults to /login with a
   // redirectTo back to the original path.
@@ -65,21 +69,25 @@ export type DashboardLoaderOptions<TParams, TSearchParams> = {
   unauthorizedRedirect?: string;
 };
 
-export type DashboardLoaderHandlerArgs<TParams, TSearchParams> = {
+export type DashboardLoaderHandlerArgs<TParams, TSearchParams, TContext> = {
   params: InferZod<TParams>;
   searchParams: InferZod<TSearchParams>;
   user: SessionUser;
   ability: RbacAbility;
+  context: TContext;
   request: Request;
 };
 
 export function dashboardLoader<
   TParams extends AnyZodSchema | undefined = undefined,
   TSearchParams extends AnyZodSchema | undefined = undefined,
+  TContext extends AuthScope = AuthScope,
   TReturn extends Response = Response
 >(
-  options: DashboardLoaderOptions<TParams, TSearchParams>,
-  handler: (args: DashboardLoaderHandlerArgs<TParams, TSearchParams>) => Promise<TReturn>
+  options: DashboardLoaderOptions<TParams, TSearchParams, TContext>,
+  handler: (
+    args: DashboardLoaderHandlerArgs<TParams, TSearchParams, TContext>
+  ) => Promise<TReturn>
 ) {
   return async function loader({ request, params }: LoaderFunctionArgs): Promise<TReturn> {
     // Server-only — see comment at top. Node caches the module after the
@@ -93,30 +101,28 @@ export function dashboardLoader<
       searchParams: result.searchParams as InferZod<TSearchParams>,
       user: result.user,
       ability: result.ability,
+      context: result.context as TContext,
       request,
     });
   };
 }
 
-export type DashboardActionOptions<TParams, TSearchParams> = DashboardLoaderOptions<
-  TParams,
-  TSearchParams
->;
+export type DashboardActionOptions<TParams, TSearchParams, TContext extends AuthScope> =
+  DashboardLoaderOptions<TParams, TSearchParams, TContext>;
 
-export type DashboardActionHandlerArgs<TParams, TSearchParams> = DashboardLoaderHandlerArgs<
-  TParams,
-  TSearchParams
-> & {
-  request: Request;
-};
+export type DashboardActionHandlerArgs<TParams, TSearchParams, TContext> =
+  DashboardLoaderHandlerArgs<TParams, TSearchParams, TContext>;
 
 export function dashboardAction<
   TParams extends AnyZodSchema | undefined = undefined,
   TSearchParams extends AnyZodSchema | undefined = undefined,
+  TContext extends AuthScope = AuthScope,
   TReturn extends Response = Response
 >(
-  options: DashboardActionOptions<TParams, TSearchParams>,
-  handler: (args: DashboardActionHandlerArgs<TParams, TSearchParams>) => Promise<TReturn>
+  options: DashboardActionOptions<TParams, TSearchParams, TContext>,
+  handler: (
+    args: DashboardActionHandlerArgs<TParams, TSearchParams, TContext>
+  ) => Promise<TReturn>
 ) {
   return async function action({ request, params }: ActionFunctionArgs): Promise<TReturn> {
     const { authenticateAndAuthorize } = await import("./dashboardBuilder.server");
@@ -128,6 +134,7 @@ export function dashboardAction<
       searchParams: result.searchParams as InferZod<TSearchParams>,
       user: result.user,
       ability: result.ability,
+      context: result.context as TContext,
       request,
     });
   };