fix(amplify-nodejs-function-runtime-provider): fix lambda error format (

#6350)

return proper error message and stack if a string error is provided return string error as is

fix #5553

packages/amplify-nodejs-function-runtime-provider/src/__tests__/utils/handlers.js

@@ -33,3 +33,11 @@ module.exports.callbackHandler = async (event, context, callback) => {
 module.exports.nonAsyncHandler = () => {
   return 'foo';
 };
+
+module.exports.undefinedVariableHandler = (event, context, callback) => {
+  console.log(undedvar);
+};
+
+module.exports.stringErrorHandler = (event, context, callback) => {
+  throw 'string';
+};

packages/amplify-nodejs-function-runtime-provider/src/__tests__/utils/invoke.test.ts

@@ -1,10 +1,9 @@
 import * as execa from 'execa';
 import { invoke } from '../../utils/invoke';
-import { InvokeOptions } from '../../utils/invokeOptions';
+import { InvokeOptions } from '../../utils/invokeUtils';
 
 jest.mock('execa');
 const execa_mock = execa as jest.Mocked<typeof execa>;
-
 class ExecaChildProcessMock {
   public stdout = {
     on: jest.fn(),
@@ -213,4 +212,4 @@ describe('invoke', () => {
       await expect(promise).rejects.toEqual(error);
     });
   });
-});
+});

packages/amplify-nodejs-function-runtime-provider/src/__tests__/utils/invokeExecute.test.ts

@@ -0,0 +1,40 @@
+import * as execa from 'execa';
+import path from 'path';
+import { invoke } from '../../utils/invoke';
+
+jest.setTimeout(60000);
+jest.mock('../../utils/invokeUtils', () => ({
+  ...(jest.requireActual('../../utils/invokeUtils') as any),
+  getLambdaChildProcess: jest.fn().mockImplementation((environment: any, functionName: string = 'execute.js') => {
+    return execa.node(path.join(__dirname, '..', '..', '..', 'lib', 'utils', functionName), [], {
+      env: environment || {},
+    });
+  })
+}));
+
+describe('test invoke with execute', () => {
+  it('should fail with proper error', async () => {
+    await expect(invoke({
+      packageFolder: __dirname,
+      handler: 'handlers.undefinedVariableHandler',
+      event: '{}',
+      environment: {}
+    })).rejects.toMatchObject({
+      message: 'undedvar is not defined',
+      stack: expect.stringContaining('ReferenceError: undedvar is not defined'),
+      type: 'Lambda:Unhandled'
+    })
+  });
+
+  it('should fail with string error', async () => {
+    await expect(invoke({
+      packageFolder: __dirname,
+      handler: 'handlers.stringErrorHandler',
+      event: '{}',
+      environment: {}
+    })).rejects.toMatchObject({
+      type: 'Lambda:Unhandled',
+      message: 'Unknown Error'
+    });
+  });
+});

packages/amplify-nodejs-function-runtime-provider/src/utils/execute.ts

@@ -1,5 +1,5 @@
 import { existsSync } from 'fs-extra';
-import { InvokeOptions } from './invokeOptions';
+import { InvokeOptions } from './invokeUtils';
 import path from 'path';
 import _ from 'lodash';
 import exit from 'exit';
@@ -95,14 +95,12 @@ process.on('message', async options => {
     process.stdout.write('\n');
     process.stdout.write(JSON.stringify({ result, error: null }));
   } catch (error) {
+    let lambdaError = typeof error === 'string' ? { message: 'Unknown Error' } : { message: error.message, stack: error.stack };
     process.stdout.write('\n');
     process.stdout.write(
       JSON.stringify({
         result: null,
-        error: {
-          type: 'Lambda:Unhandled',
-          message: error.message || typeof error === 'string' ? error : 'Unknown error', // In case of callback('error'), it is only a string
-        },
+        error: { type: 'Lambda:Unhandled', ...lambdaError },
       }),
     );
   }

packages/amplify-nodejs-function-runtime-provider/src/utils/invoke.ts

@@ -1,15 +1,11 @@
-import { InvokeOptions } from './invokeOptions';
-import path from 'path';
-import * as execa from 'execa';
+import { InvokeOptions, getLambdaChildProcess } from './invokeUtils';
 
 // copied from amplify-util-mock with slight modifications
 export function invoke(options: InvokeOptions): Promise<any> {
   return new Promise((resolve, reject) => {
     try {
       let data: string = '';
-      const lambdaFn = execa.node(path.join(__dirname, 'execute.js'), [], {
-        env: options.environment || {},
-      });
+      const lambdaFn = getLambdaChildProcess(options.environment);
       lambdaFn.stdout.on('data', msg => {
         data += msg;
       });

packages/amplify-nodejs-function-runtime-provider/src/utils/invokeUtils.ts

@@ -0,0 +1,16 @@
+import path from 'path';
+import * as execa from 'execa';
+
+export type InvokeOptions = {
+  packageFolder: string;
+  handler: string;
+  event: string;
+  context?: object;
+  environment?: { [key: string]: string };
+};
+
+export const getLambdaChildProcess = (environment: any, functionName: string = 'execute.js'): execa.ExecaChildProcess => {
+  return execa.node(path.join(__dirname, functionName), [], {
+    env: environment || {},
+  });
+}