refactor(core,toolkit): relocate customJwt local vm handler

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

@@ -1,4 +1,3 @@
-import { buildErrorResponse, runScriptFunctionInLocalVm } from '@logto/core-kit/custom-jwt';
 import {
   LogtoJwtTokenKeyType,
   jwtCustomizerUserContextGuard,
@@ -22,6 +21,8 @@
 import {
   LocalVmError,
   getJwtCustomizerScripts,
+  runScriptFunctionInLocalVm,
+  buildLocalVmErrorBody,
   type CustomJwtDeployRequestBody,
 } from '#src/utils/custom-jwt/index.js';
 
@@ -53,13 +54,13 @@
       }
 
       throw new LocalVmError(
-        buildErrorResponse(error),
+        buildLocalVmErrorBody(error),
         error instanceof SyntaxError || error instanceof TypeError ? 422 : 500
       );
     }
   }
 
   constructor(
     private readonly queries: Queries,
     private readonly logtoConfigs: LogtoConfigLibrary,
     private readonly cloudConnection: CloudConnectionLibrary,

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

@@ -1,3 +1,13 @@
-export * from './custom-jwt.js';
+import { LogtoJwtTokenKey, type JwtCustomizerType } from '@logto/schemas';
+
+import { type CustomJwtDeployRequestBody } from './types.js';
+
 export * from './types.js';
-export * from './local-vm-error.js';
+export * from './local-vm.js';
+
+export const getJwtCustomizerScripts = (jwtCustomizers: Partial<JwtCustomizerType>) => {
+  // eslint-disable-next-line no-restricted-syntax -- enable to infer the type using `Object.fromEntries`
+  return Object.fromEntries(
+    Object.values(LogtoJwtTokenKey).map((key) => [key, { production: jwtCustomizers[key]?.script }])
+  ) as CustomJwtDeployRequestBody;
+};

packages/toolkit/core-kit/src/custom-jwt/script-execution.ts → packages/core/src/utils/custom-jwt/local-vm.ts

@@ -1,5 +1,28 @@
+import { types } from 'node:util';
 import { runInNewContext } from 'node:vm';
 
+import { ResponseError } from '@withtyped/client';
+
+/**
+ * Extend the ResponseError from @withtyped/client.
+ * This class is used to parse the error from the local VM to the WithTyped client response error.
+ * So we can unify the error handling and display logic for both local VM and Cloud version.
+ */
+export class LocalVmError extends ResponseError {
+  constructor(errorBody: Record<string, unknown>, statusCode: number) {
+    super(
+      new Response(
+        new Blob([JSON.stringify(errorBody)], {
+          type: 'application/json',
+        }),
+        {
+          status: statusCode,
+        }
+      )
+    );
+  }
+}
+
 /**
  * This function is used to execute a named function in a customized code script in a local
  * virtual machine with the given payload as input.
@@ -39,3 +62,18 @@ export const runScriptFunctionInLocalVm = async (
 
   return result;
 };
+
+/**
+ * Build the error body for the local VM error.
+ *
+ * @remarks
+ *
+ * Catch the error from vm module, and build the error body.
+ * Use `isNativeError` to check if the error is an instance of `Error`.
+ * If the error comes from `node:vm` module, then it will not be an instance of `Error` but can be captured by `isNativeError`.
+ *
+ */
+export const buildLocalVmErrorBody = (error: unknown) =>
+  types.isNativeError(error)
+    ? { message: error.message, stack: error.stack }
+    : { message: String(error) };