feat(core,schemas): add denyAccess api context to custom jwt

add denyAccess api context to custom jwt

packages/core/src/libraries/jwt-customizer.ts

@@ -1,14 +1,18 @@
 import {
+  type CustomJwtErrorBody,
+  CustomJwtErrorCode,
   LogtoJwtTokenKeyType,
   jwtCustomizerUserContextGuard,
   userInfoSelectFields,
   type CustomJwtFetcher,
   type JwtCustomizerType,
   type JwtCustomizerUserContext,
   type LogtoJwtTokenKey,
+  type JwtCustomizerApiContext,
+  type CustomJwtScriptPayload,
 } from '@logto/schemas';
 import { type ConsoleLog } from '@logto/shared';
-import { assert, deduplicate, pick, pickState } from '@silverhand/essentials';
+import { assert, conditional, deduplicate, pick, pickState } from '@silverhand/essentials';
 import deepmerge from 'deepmerge';
 import { ZodError, z } from 'zod';
 
@@ -28,19 +32,43 @@ import {
 
 import { type CloudConnectionLibrary } from './cloud-connection.js';
 
+const apiContext: JwtCustomizerApiContext = Object.freeze({
+  denyAccess: (message?: string) => {
+    const error: CustomJwtErrorBody = {
+      code: CustomJwtErrorCode.AccessDenied,
+      message: message ?? 'Access denied',
+    };
+
+    throw new LocalVmError(error, 403);
+  },
+});
+
 export class JwtCustomizerLibrary {
   // Convert errors to WithTyped client response error to share the error handling logic.
   static async runScriptInLocalVm(data: CustomJwtFetcher) {
     try {
-      const payload =
-        data.tokenType === LogtoJwtTokenKeyType.AccessToken
+      // @ts-expect-error -- remove this when the dev feature is ready
+      const payload: CustomJwtScriptPayload = {
+        ...(data.tokenType === LogtoJwtTokenKeyType.AccessToken
           ? pick(data, 'token', 'context', 'environmentVariables')
-          : pick(data, 'token', 'environmentVariables');
+          : pick(data, 'token', 'environmentVariables')),
+        ...conditional(
+          // TODO: @simeng remove this when the dev feature is ready
+          EnvSet.values.isDevFeaturesEnabled && {
+            api: apiContext,
+          }
+        ),
+      };
+
       const result = await runScriptFunctionInLocalVm(data.script, 'getCustomJwtClaims', payload);
 
       // If the `result` is not a record, we cannot merge it to the existing token payload.
       return z.record(z.unknown()).parse(result);
     } catch (error: unknown) {
+      if (error instanceof LocalVmError) {
+        throw error;
+      }
+
       // Assuming we only use zod for request body validation
       if (error instanceof ZodError) {
         const { errors } = error;

packages/core/src/oidc/extra-token-claims.ts

@@ -6,10 +6,12 @@ import {
   jwtCustomizer as jwtCustomizerLog,
   type CustomJwtFetcher,
   GrantType,
+  CustomJwtErrorCode,
 } from '@logto/schemas';
 import { generateStandardId } from '@logto/shared';
 import { conditional, trySafe } from '@silverhand/essentials';
-import { type KoaContextWithOIDC, type UnknownObject } from 'oidc-provider';
+import { ResponseError } from '@withtyped/client';
+import { errors, type KoaContextWithOIDC, type UnknownObject } from 'oidc-provider';
 import { z } from 'zod';
 
 import { EnvSet } from '#src/env-set/index.js';
@@ -20,6 +22,8 @@ import { LogEntry } from '#src/middleware/koa-audit-log.js';
 import type Libraries from '#src/tenants/Libraries.js';
 import type Queries from '#src/tenants/Queries.js';
 
+import { parseCustomJwtResponseError } from '../utils/custom-jwt/index.js';
+
 import { tokenExchangeActGuard } from './grants/token-exchange/types.js';
 
 /**
@@ -196,11 +200,14 @@ export const getExtraTokenClaimsForJwtCustomization = async (
           : jwtCustomizerLog.Type.AccessToken
       }`
     );
+
     entry.append({
       result: LogResult.Error,
       error: { message: String(error) },
     });
+
     const { payload } = entry;
+
     await queries.logs.insertLog({
       id: generateStandardId(),
       key: payload.key,
@@ -210,6 +217,15 @@ export const getExtraTokenClaimsForJwtCustomization = async (
         token,
       },
     });
+
+    // If the error is an instance of `ResponseError`, we need to parse the error body to get the error code.
+    if (error instanceof ResponseError) {
+      const result = await trySafe(async () => parseCustomJwtResponseError(error));
+
+      if (result?.code === CustomJwtErrorCode.AccessDenied) {
+        throw new errors.AccessDenied(result.message);
+      }
+    }
   }
 };
 /* eslint-enable complexity */

packages/core/src/routes/logto-config/jwt-customizer.ts

@@ -18,6 +18,7 @@ import { JwtCustomizerLibrary } from '#src/libraries/jwt-customizer.js';
 import koaGuard, { parse } from '#src/middleware/koa-guard.js';
 import { koaQuotaGuard } from '#src/middleware/koa-quota-guard.js';
 import { getConsoleLogFromContext } from '#src/utils/console.js';
+import { parseCustomJwtResponseError } from '#src/utils/custom-jwt/index.js';
 
 import type { ManagementApiRouter, RouterInitArgs } from '../types.js';
 
@@ -249,8 +250,12 @@ export default function logtoConfigJwtCustomizerRoutes<T extends ManagementApiRo
          * format of `RequestError`, we manually transform it here to keep the error format consistent.
          */
         if (error instanceof ResponseError) {
-          const { message } = z.object({ message: z.string() }).parse(await error.response.json());
-          throw new RequestError({ code: 'jwt_customizer.general', status: 422 }, { message });
+          const { code, message } = await parseCustomJwtResponseError(error);
+
+          throw new RequestError(
+            { code: 'jwt_customizer.general', status: 422 },
+            { message, code }
+          );
         }
 
         if (error instanceof ZodError) {

packages/core/src/utils/custom-jwt/index.ts

@@ -1,4 +1,7 @@
-import { LogtoJwtTokenKey, type JwtCustomizerType } from '@logto/schemas';
+import { LogtoJwtTokenKey, type JwtCustomizerType, customJwtErrorBodyGuard } from '@logto/schemas';
+import { type ResponseError } from '@withtyped/client';
+
+import RequestError from '../../errors/RequestError/index.js';
 
 import { type CustomJwtDeployRequestBody } from './types.js';
 
@@ -11,3 +14,19 @@ export const getJwtCustomizerScripts = (jwtCustomizers: Partial<JwtCustomizerTyp
     Object.values(LogtoJwtTokenKey).map((key) => [key, { production: jwtCustomizers[key]?.script }])
   ) as CustomJwtDeployRequestBody;
 };
+
+export const parseCustomJwtResponseError = async (error: ResponseError) => {
+  const result = customJwtErrorBodyGuard.safeParse(await error.response.json());
+
+  if (!result.success) {
+    throw new RequestError(
+      {
+        code: 'jwt_customizer.general',
+        status: 500,
+      },
+      { message: result.error.message }
+    );
+  }
+
+  return result.data;
+};

packages/integration-tests/src/__mocks__/jwt-customizer.ts

@@ -58,6 +58,16 @@ export const accessTokenSampleScript = `const getCustomJwtClaims = async ({ toke
   return { user_id: context?.user?.id ?? 'unknown', hasPassword: context?.user?.hasPassword };
 };`;
 
+export const accessTokenAccessDeniedSampleScript = `const getCustomJwtClaims = async ({ token, context, environmentVariables, api }) => {
+  api.denyAccess('You are not allowed to access this resource');
+  return { test: 'foo'};
+};`;
+
 export const clientCredentialsSampleScript = `const getCustomJwtClaims = async ({ token, context, environmentVariables }) => {
   return { ...environmentVariables };
 }`;
+
+export const clientCredentialsAccessDeniedSampleScript = `const getCustomJwtClaims = async ({ token, context, environmentVariables, api }) => {
+  api.denyAccess('You are not allowed to access this resource');
+  return { test: 'foo'};
+};`;

packages/integration-tests/src/tests/api/logto-config.test.ts

@@ -11,6 +11,8 @@ import {
   clientCredentialsJwtCustomizerPayload,
   accessTokenSampleScript,
   clientCredentialsSampleScript,
+  accessTokenAccessDeniedSampleScript,
+  clientCredentialsAccessDeniedSampleScript,
 } from '#src/__mocks__/jwt-customizer.js';
 import {
   deleteOidcKey,
@@ -26,6 +28,7 @@ import {
   testJwtCustomizer,
 } from '#src/api/index.js';
 import { expectRejects } from '#src/helpers/index.js';
+import { devFeatureTest } from '#src/utils.js';
 
 const defaultAdminConsoleConfig: AdminConsoleData = {
   signInExperienceCustomized: false,
@@ -268,4 +271,41 @@ describe('admin console sign-in experience', () => {
     });
     expect(testResult).toMatchObject(clientCredentialsJwtCustomizerPayload.environmentVariables);
   });
+
+  devFeatureTest.it(
+    'should throw access denied error when calling the denyAccess api in the script',
+    async () => {
+      await expectRejects(
+        testJwtCustomizer({
+          tokenType: LogtoJwtTokenKeyType.AccessToken,
+          token: accessTokenJwtCustomizerPayload.tokenSample,
+          context: accessTokenJwtCustomizerPayload.contextSample,
+          script: accessTokenAccessDeniedSampleScript,
+          environmentVariables: accessTokenJwtCustomizerPayload.environmentVariables,
+        }),
+        {
+          code: 'oidc.access_denied',
+          status: 400,
+        }
+      );
+    }
+  );
+
+  devFeatureTest.it(
+    'should throw access denied error when calling the denyAccess api in the script',
+    async () => {
+      await expectRejects(
+        testJwtCustomizer({
+          tokenType: LogtoJwtTokenKeyType.ClientCredentials,
+          token: clientCredentialsJwtCustomizerPayload.tokenSample,
+          script: clientCredentialsAccessDeniedSampleScript,
+          environmentVariables: clientCredentialsJwtCustomizerPayload.environmentVariables,
+        }),
+        {
+          code: 'oidc.access_denied',
+          status: 400,
+        }
+      );
+    }
+  );
 });

packages/schemas/src/types/logto-config/jwt-customizer.ts

@@ -145,3 +145,52 @@ export const customJwtFetcherGuard = z.discriminatedUnion('tokenType', [
 ]);
 
 export type CustomJwtFetcher = z.infer<typeof customJwtFetcherGuard>;
+
+export enum CustomJwtErrorCode {
+  /**
+   * The `AccessDenied` error explicitly thrown
+   * by calling the `api.denyAccess` function in the custom JWT script.
+   */
+  AccessDenied = 'AccessDenied',
+  /** General JWT customizer error,
+   * this is the fallback custom jwt error code
+   * for any internal error thrown by the JWT customizer (localVM, azure function, or CF worker).
+   */
+  General = 'General',
+}
+
+export const customJwtErrorBodyGuard = z
+  .object({
+    code: z.nativeEnum(CustomJwtErrorCode).optional(),
+    message: z.string(),
+  })
+  .catchall(z.unknown());
+
+export type CustomJwtErrorBody = z.infer<typeof customJwtErrorBodyGuard>;
+
+export type JwtCustomizerApiContext = {
+  /**
+   * Reject the the current token exchange request.
+   *
+   * @remarks
+   * By calling this function, the current token exchange request will be rejected,
+   * and a ODIC `AccessDenied` error will be thrown to the client with the given message.
+   *
+   * @param message The message to be shown to the user.
+   * @throws {ResponseError} with `CustomJwtErrorBody`
+   */
+  denyAccess: (message?: string) => never;
+};
+
+/**
+ * The payload type for the custom JWT script.
+ *
+ * @remarks
+ * We use this type to guard the input payload for the custom JWT script.
+ */
+export type CustomJwtScriptPayload = {
+  token: Record<string, unknown>;
+  context?: Record<string, unknown>;
+  environmentVariables?: Record<string, string>;
+  api: JwtCustomizerApiContext;
+};