Request body idToken and access token is received as undefined when lambda integration is turned on, in serverless

[karthikpower]

I want to enable lambda integration for auth endpoint which is post and expects idToken and accessToken in its payload. When I observe cloudwatch log printing req.body.idToken or req.body.accessToken I see it is printed as undefined but when turning off lambda integration I see idToken and accessToken getting printed. So I want to understand if there is any limit that can be passed in payload if integration is turned on?

Here is my serverless.yml

'service: my-service-api

provider:
  name: aws
  runtime: nodejs16.x
  memorySize: 256 
  timeout: 10 
  region: us-west-2
  profile: xyz
  versionFunctions: false
  endpointType: regional
  deploymentBucket:
    name: ps-serverless
  vpc: xyz
  apiGateway:
    restApiId: xyz
    restApiRootResourceId: xyz
    restApiResources:
      /district-settings: xyz
plugins:
  - serverless-offline

custom:
  corsOptions:
    origin: http://localhost:3000/
    headers:
      - Content-Type
      - X-Amz-Date
      - Authorization
      - X-Api-Key
      - X-Amz-Security-Token
      - X-Amz-User-Agent
      - X-Xsrf-Token
    allowCredentials: true
  requestTemplate:
    application/json: |
      #set($request_header = $input.params().header)
      #set($request_query = $input.params().querystring) 
      #set($request_path = $input.params().path)
      #set($request_stage_vars = $stageVariables)
      #set($request_context = $context) 
      {  
        "body": "$util.escapeJavaScript($input.json('$'))",
        "httpMethod": "$context.httpMethod",
        "headers": {
        #foreach($header in $request_header.keySet())
              "$header" : "$util.escapeJavaScript($request_header.get($header))"
              #if($foreach.hasNext),#end
              #end
            }, 

        "queryStringParameters": {
        #foreach($query in $request_query.keySet())
              "$query" : "$util.urlDecode($request_query.get($query))"
              #if($foreach.hasNext),#end
              #end
            }, 

        "pathParameters": {
        #foreach($path in $request_path.keySet())
              "$path" : "$util.escapeJavaScript($request_path.get($path))"
              #if($foreach.hasNext),#end
              #end
            }, 

        "stageVariables": {
        #foreach($stage in $request_stage_vars.keySet())
              "$stage" : "$util.escapeJavaScript($request_stage_vars.get($stage))"
              #if($foreach.hasNext),#end
              #end
            }, 
        "resource": "$context.resourcePath",
        "path":"$context.path",
        "requestContext": {
        #foreach($reqContext in $request_context.keySet())
              "$reqContext" : "$util.escapeJavaScript($request_context.get($reqContext))"
              #if($foreach.hasNext),#end
              #end
            },
        "isBase64Encoded": false
      }

  responseHeaders:
    headers:
      Content-Type: ${env:CONTENT_TYPE}
      Access-Control-Allow-Credentials: ${env:ALLOW_CREDENTIAL}
      Strict-Transport-Security: ${env:SECURE_TRANSPORT_SECURITY}
      Cache-Control: ${env:CACHE_CONTROL}
      Content-Security-Policy: ${env:DEFAULT_CSP}
      X-Content-Type-Options: ${env:CONTENT_TYPE_OPTIONS}
      X-XSS-Protection: ${env:XSS_PROTECTION}
      X-Frame-Options: ${env:X_FRAME_OPTIONS}
      Pragma: ${env:PRAGMA}

    statusCodes:
      200:
        pattern: ''
        template:
          application/json: |
            #set($body = $input.json('$.body'))
            #set($statusCode = $input.json('$.statusCode'))
            #set($Integer = 0)
            $util.parseJson($body)
            #set($origin = $input.params().header)
            #set($context.responseOverride.header.Access-Control-Allow-Origin = $origin)
            #if($body.contains("error"))
            #set($context.responseOverride.status = $Integer.parseInt($statusCode))
            #end

functions:
 authAuth0:
    handler: src/auth/auth-handler.auth0
    events:
      - http:
          path: '${self:custom.pathPrefix}/auth/auth0'
          method: post
          cors: ${self:custom.corsOptions}
          integration: lambda
          request:
            passThrough: NEVER
            template: ${self:custom.requestTemplate}
          response: ${self:custom.docsResponseHeaders}

  async (req: Request, res: Response, next: NextFunction): Promise<void> => {
    try {

      if (sessionIsActive(req.session)) {
        logger.info(`Token TTL refreshed for user ${req.session.userInfo?.uid}`);

        res.status(HttpStatusCodes.OK).send({ success: true });
      } else if (req.body.idToken) {
        const xsrfCookieConfig = getXsrfCookieOptions();
        // Return the decoded payload from idToken
        const jwtPayload: Auth0IdToken = await container
          .get<IAuthService>(Symbol.for('IAuthService'))
          .verifyAuth0IdToken(req.body.idToken);
        logger.debug(`Auth0 ID Token is valid`);
        // create or update the user record in the user table, according to the decoded payload
        const userInfo = await container
          .get<IAuthService>(Symbol.for('IAuthService'))
          .createUserRecordfromAuth0(jwtPayload);

        req.session.status = true;
        req.session.expiresAt = calcSessionExp();
        req.session.userInfo = userInfo;
        req.session.accessToken = req.body.accessToken;
        res.cookie(Cookies.csrf, req.csrfToken(), xsrfCookieConfig);
        res.status(HttpStatusCodes.OK).send({ success: true });
      } else {
        logger.error('No active session or idToken provided');
        req.session.destroy(_ => {});
        next(unauthorized());
      }
    } catch (err) {
      logger.error('Unable to create a session');
      req.session.destroy(_ => {});
      next(err);
    }
  }

This is the sample payload,

{
  "accessToken": "<<actual access_token in real scenario>>",
  "idToken": "<<actual id_token in real scenario>>"
}

Has anyone faced this when lambda int is turned or any suggestion would be of great help, thanks.