Merge pull request #953 from MoralisWeb3/fix/serialisation-nextjs-req…

…uests

fix: serialisation nextjs requests

.changeset/big-mangos-mix.md

@@ -0,0 +1,5 @@
+---
+'@moralisweb3/next': patch
+---
+
+Fix requests that can return null response

.changeset/five-moles-turn.md

@@ -0,0 +1,5 @@
+---
+'@moralisweb3/next': patch
+---
+
+Fix issues related to several NextJS hooks, due to the serialisation of the request

demos/parse-server-migration/src/cloud/upgradeRequest.ts

@@ -1,6 +1,5 @@
-import { Operation, toCamelCase } from '@moralisweb3/common-core';
-
-type UnknownOperation = Operation<unknown, unknown, unknown, unknown>;
+import { UnknownOperation } from '@moralisweb3/common-core';
+import { toCamelCase } from '@moralisweb3/common-core';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function upgradeRequest(params: any, operation: UnknownOperation): any {

packages/apiUtils/src/resolvers2/index.ts

@@ -2,3 +2,4 @@ export * from './OperationResolver';
 export * from './NullableOperationResolver';
 export * from './PaginatedOperationResolver';
 export * from './NullableOperationResolver';
+export * from './types';

packages/apiUtils/src/resolvers2/types.ts

@@ -0,0 +1,12 @@
+import { NullableOperationResolver } from './NullableOperationResolver';
+import { OperationResolver } from './OperationResolver';
+import { PaginatedOperationResolver } from './PaginatedOperationResolver';
+
+export type UnknownNullableOperationResolver = NullableOperationResolver<unknown, unknown, unknown, unknown>;
+export type UnknownPaginatedOperationResolver = PaginatedOperationResolver<any, unknown, unknown, unknown>;
+export type UnknownDefaultOperationResolver = OperationResolver<unknown, unknown, unknown, unknown>;
+
+export type UnknownOperationResolver =
+  | UnknownNullableOperationResolver
+  | UnknownPaginatedOperationResolver
+  | UnknownDefaultOperationResolver;

packages/codegen/src/next/types.ts

@@ -1,6 +1,5 @@
-import { Operation } from '@moralisweb3/common-core';
+import { UnknownOperation } from '@moralisweb3/common-core';
 
-export type UnknownOperation = Operation<unknown, unknown, unknown, unknown>;
 export type OperationAction = Pick<UnknownOperation, 'name' | 'groupName' | 'method' | 'id' | 'urlSearchParamNames'>;
 
 export type Module = 'evmApi' | 'solApi' | 'auth';

packages/common/core/src/operations/Operation.ts

@@ -26,3 +26,5 @@ export type OperationRequestUrlParams = Record<string, string | string[] | boole
 export type OperationRequestBody = OperationRequestPropertiesBody | OperationRequestRawBody;
 export type OperationRequestPropertiesBody = Record<string, unknown>;
 export type OperationRequestRawBody = string | number | boolean | object;
+
+export type UnknownOperation = Operation<unknown, unknown, unknown, unknown>;

packages/next/src/MoralisNextApi/Modules.ts

@@ -0,0 +1,59 @@
+import { EvmApi } from '@moralisweb3/evm-api';
+import Core, { UnknownOperation } from '@moralisweb3/common-core';
+import { operations as evmOperations } from 'moralis/common-evm-utils';
+import { operations as solOperations } from 'moralis/common-sol-utils';
+import { operations as authOperations } from '@moralisweb3/common-auth-utils';
+import { Auth } from '@moralisweb3/auth';
+import { SolApi } from '@moralisweb3/sol-api';
+import { UnknownOperationResolver } from '@moralisweb3/api-utils';
+
+export class Module {
+  constructor(public readonly moduleName: string, public readonly operations: UnknownOperation[]) {}
+
+  getOperationByName(operationName: string) {
+    const operation = this.operations.find((op) => op.name === operationName);
+
+    if (!operation) {
+      throw new Error(`Operation ${operationName} not found`);
+    }
+
+    return operation;
+  }
+
+  getRequestHandler(operation: UnknownOperation, core: Core) {
+    const apiModule = core.getModule(this.moduleName) as unknown as Record<
+      string,
+      Record<string, UnknownOperationResolver['fetch']>
+    >;
+
+    const apiGroup = apiModule[operation.groupName];
+
+    if (!apiGroup) {
+      throw new Error(`Operation ${operation.name} has no group name in ${this.moduleName}`);
+    }
+
+    const requestHandler = apiGroup[operation.name];
+
+    if (!requestHandler) {
+      throw new Error(`Operation ${operation.name} has no requestHandler in ${this.moduleName}.${apiGroup}`);
+    }
+
+    return requestHandler;
+  }
+}
+
+const modules: Module[] = [
+  new Module(EvmApi.moduleName, evmOperations as UnknownOperation[]),
+  new Module(SolApi.moduleName, solOperations as UnknownOperation[]),
+  new Module(Auth.moduleName, authOperations as UnknownOperation[]),
+];
+
+export function getModuleByName(moduleName: string) {
+  const module = modules.find((currentModule) => currentModule.moduleName === moduleName);
+
+  if (!module) {
+    throw new Error(`Module ${moduleName} not found`);
+  }
+
+  return module;
+}

packages/next/src/MoralisNextApi/MoralisNextApi.ts

@@ -1,28 +1,32 @@
 import { MoralisNextApiParams, MoralisNextHandlerParams } from './types';
-import { RequestHandlerResolver } from './RequestHandlerResolver';
 import Moralis from 'moralis';
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { authOperationNames, moralisNextAuthHandler } from '../auth/moralisNextAuthHandler';
+import { getModuleByName } from './Modules';
 import { isMoralisError } from '@moralisweb3/common-core';
 import { serverLogger } from '../serverLogger';
 
 const FALLBACK_ERROR_MESSAGE = 'Internal Server Error';
 
-async function MoralisNextHandler({ req, res, authentication }: MoralisNextHandlerParams) {
+async function MoralisNextHandler({ req, res, authentication, core }: MoralisNextHandlerParams) {
   const [moduleName, operationName] = req.query.moralis as string[];
 
   try {
-    const requestHandler = RequestHandlerResolver.tryResolve(moduleName, operationName);
+    const module = getModuleByName(moduleName);
+    const operation = module.getOperationByName(operationName);
+    const deserialisedRequest = operation.deserializeRequest(req.body, core);
+    const requestHandler = module.getRequestHandler(operation, core);
+
     if (!requestHandler) {
       return res.status(400).json({ error: `Operation ${moduleName}/${operationName} is not supported` });
     }
 
     let response;
 
     if (authOperationNames.includes(operationName)) {
-      response = await moralisNextAuthHandler({ req, res, authentication, requestHandler, operationName });
+      response = await moralisNextAuthHandler({ req, res, authentication, requestHandler, operation, core });
     } else {
-      response = await requestHandler.fetch(req.body);
+      response = await requestHandler(deserialisedRequest);
     }
 
     return res.status(200).json(response);
@@ -50,7 +54,8 @@ const MoralisNextApi = ({ authentication, ...config }: MoralisNextApiParams) =>
     Moralis.start(config);
   }
 
-  return async (req: NextApiRequest, res: NextApiResponse) => MoralisNextHandler({ req, res, authentication });
+  return async (req: NextApiRequest, res: NextApiResponse) =>
+    MoralisNextHandler({ req, res, authentication, core: Moralis.Core });
 };
 
 export default MoralisNextApi;

packages/next/src/MoralisNextApi/types.ts

@@ -1,6 +1,6 @@
 import { ApiUtilsConfigValues } from '@moralisweb3/api-utils';
 import { RequestChallengeEvmRequest, RequestChallengeSolanaRequest } from '@moralisweb3/common-auth-utils';
-import { MoralisCoreConfigValues } from 'moralis/common-core';
+import { MoralisCoreConfigValues, Core } from 'moralis/common-core';
 import type { NextApiRequest, NextApiResponse } from 'next';
 
 export type MoralisConfigValues = MoralisCoreConfigValues | ApiUtilsConfigValues;
@@ -15,4 +15,5 @@ export interface MoralisNextHandlerParams {
   req: NextApiRequest;
   res: NextApiResponse;
   authentication?: AuthConfig;
+  core: Core;
 }

packages/next/src/auth/moralisNextAuthHandler.ts

@@ -1,4 +1,5 @@
-import { OperationResolver } from '@moralisweb3/api-utils';
+import { UnknownOperationResolver } from '@moralisweb3/api-utils';
+import { UnknownOperation } from '@moralisweb3/common-core';
 import { MoralisNextHandlerParams } from '../MoralisNextApi/types';
 
 export const authOperationNames = [
@@ -9,28 +10,33 @@ export const authOperationNames = [
 ];
 
 export interface MoralisNextAuthHandler extends MoralisNextHandlerParams {
-  requestHandler: OperationResolver<unknown, unknown, unknown, unknown>;
-  operationName: string;
+  requestHandler: UnknownOperationResolver['fetch'];
+  operation: UnknownOperation;
 }
 
 export const moralisNextAuthHandler = async ({
   req,
   authentication,
   requestHandler,
-  operationName,
+  operation,
+  core,
 }: MoralisNextAuthHandler) => {
+  const operationName = operation.name;
   if (!authentication) {
     throw new Error(
       `Error running the '${operationName}' operation. No authentication config provided in 'pages/api/moralis/[...moralis].ts'`,
     );
   }
+
+  const deserlialisedRequest = operation.deserializeRequest(req.body, core) as Record<string, unknown>;
+
   switch (operationName) {
     case 'requestChallengeEvm':
     case 'requestChallengeSolana':
-      return requestHandler.fetch({ ...req.body, ...authentication });
+      return requestHandler({ ...deserlialisedRequest, ...authentication });
     case 'verifyChallengeEvm':
     case 'verifyChallengeSolana':
-      return requestHandler.fetch(req.body);
+      return requestHandler(deserlialisedRequest);
     default:
       throw new Error(`${operationName} is not supported authentication operation`);
   }

packages/next/src/utils/fetchers/fetcher.ts

@@ -19,7 +19,7 @@ async function fetcher<Request, Response, JSONResponse>(
   endpoint = `/api/moralis/${endpoint}`;
 
   try {
-    const { data } = await axios.post<JSONResponse>(endpoint, operation.serializeRequest(request, Moralis.Core));
+    const { data } = await axios.post<JSONResponse>(endpoint, request);
     return operation.deserializeResponse(data, request, Moralis.Core);
   } catch (error) {
     // Overwrite error message if the nextjs api returns additional error details