@swydo/byol 2.0.13 → 2.0.16

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2.0.16 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.15 (2022-04-06)
+
+
+### Bug Fixes
+
+* **byol:** fix cwd not being set to CodeUri from CloudFormation file ([#363](https://github.com/Swydo/byol/issues/363)) ([8c6ce63](https://github.com/Swydo/byol/commit/8c6ce631e5c47ecfcbd3b1c5548cc8f2fcb51805))
+
+
+
+
+
+## 2.0.14 (2022-04-04)
+
+
+### Bug Fixes
+
+* **byol:** add timeout delay to print all the logs ([#356](https://github.com/Swydo/byol/issues/356)) ([937393b](https://github.com/Swydo/byol/commit/937393bed0bd8c88e4776619d27f954e7077cc71))
+
+
+
+
+
 ## 2.0.13 (2021-10-25)
 
 **Note:** Version bump only for package @swydo/byol

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@swydo/byol",
-	"version": "2.0.13",
+	"version": "2.0.16",
 	"description": "Bring Your Own Lambda",
 	"license": "MIT",
 	"engines": {
@@ -27,5 +27,5 @@
 	"peerDependencies": {
 		"aws-xray-sdk-core": "^3.0.0"
 	},
-	"gitHead": "ddbd0d81baf30424ecf45841411e07ef8fe33994"
+	"gitHead": "9b5e602f0dd5db4dfcca03c41e8fba61730cf99f"
 }

package/src/assets/callHandlerProcess.js

@@ -1,3 +1,4 @@
+const path = require('path');
 const workerpool = require('workerpool');
 const { generateRequestId } = require('../generateRequestId');
 
@@ -17,7 +18,7 @@ function hasXRay() {
 }
 
 async function execute(handler, event, awsContext) {
-    return new Promise(((resolve, reject) => {
+    const handlerResult = await new Promise(((resolve, reject) => {
         const maybePromise = handler(event, awsContext, (err, res) => {
             if (err) {
                 reject(err);
@@ -36,6 +37,12 @@ async function execute(handler, event, awsContext) {
                 .catch((err) => reject(err));
         }
     }));
+
+    // Timeout delay is required in order to print console logs
+    // that are omitted otherwise
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    return handlerResult;
 }
 
 async function executeWithXRay(segmentName, handler, event, awsContext) {
@@ -61,13 +68,15 @@ async function executeWithXRay(segmentName, handler, event, awsContext) {
 }
 
 async function callHandler({
-    absoluteIndexPath,
+    indexPath,
     handlerName,
     event,
     environment,
 }) {
     process.env = environment;
 
+    const absoluteIndexPath = path.join(process.cwd(), indexPath);
+
     const { [handlerName]: handler } = await import(absoluteIndexPath);
     const awsContext = {
         awsRequestId: generateRequestId(),

package/src/handlerWorkerPool.js

@@ -3,16 +3,16 @@ const workerpool = require('workerpool');
 
 const workerPoolMap = new Map();
 
-function getWorkerPoolKey(absoluteIndexPath, handlerName, requestId) {
+function getWorkerPoolKey(workingDirectory, indexPath, handlerName, requestId) {
     if (requestId) {
-        return `${absoluteIndexPath}:${handlerName}:${requestId}`;
+        return `${workingDirectory}:${indexPath}:${handlerName}:${requestId}`;
     }
 
-    return `${absoluteIndexPath}:${handlerName}`;
+    return `${workingDirectory}:${indexPath}:${handlerName}`;
 }
 
-function terminateWorkerPool(absoluteIndexPath, handlerName, requestId) {
-    const poolKey = getWorkerPoolKey(absoluteIndexPath, handlerName, requestId);
+function terminateWorkerPool(workingDirectory, indexPath, handlerName, requestId) {
+    const poolKey = getWorkerPoolKey(workingDirectory, indexPath, handlerName, requestId);
 
     const { pool } = workerPoolMap.get(poolKey);
     const terminationPromise = pool.terminate();
@@ -33,15 +33,20 @@ function terminateWorkerPools() {
     return Promise.all(terminationPromises);
 }
 
-async function getWorkerPool(absoluteIndexPath, handlerName, environment = {}, requestId) {
-    const poolKey = getWorkerPoolKey(absoluteIndexPath, handlerName, requestId);
+async function getWorkerPool(workingDirectory, indexPath, handlerName, environment = {}, requestId) {
+    const poolKey = getWorkerPoolKey(workingDirectory, indexPath, handlerName, requestId);
 
     if (!workerPoolMap.has(poolKey)) {
-        const pool = workerpool.pool(path.join(__dirname, 'assets', 'callHandlerProcess.js'));
+        const pool = workerpool.pool(path.join(__dirname, 'assets', 'callHandlerProcess.js'), {
+            workerType: 'process',
+            forkOpts: {
+                cwd: workingDirectory,
+            },
+        });
 
         workerPoolMap.set(poolKey, {
             pool,
-            absoluteIndexPath,
+            indexPath,
             handlerName,
             environment,
             requestId,
@@ -53,7 +58,7 @@ async function getWorkerPool(absoluteIndexPath, handlerName, environment = {}, r
     if (JSON.stringify(poolEnvironment) !== JSON.stringify(environment)) {
         terminateWorkerPool(poolKey);
 
-        return getWorkerPool(absoluteIndexPath, handlerName, environment);
+        return getWorkerPool(workingDirectory, indexPath, handlerName, environment);
     }
 
     return pool;

package/src/invokeFunction.js

@@ -61,16 +61,17 @@ async function invokeFunction(functionName, event, {
 
     const [relativePathWithoutExtension, handlerName] = handler.split('.');
 
-    const relativeIndexPath = `${relativePathWithoutExtension}.js`;
-    const absoluteIndexPath = path.join(templatePath, '..', codeUri, relativeIndexPath);
+    const workingDirectory = path.join(templatePath, '..', codeUri);
+    const indexPath = `${relativePathWithoutExtension}.js`;
 
     const options = {
-        absoluteIndexPath,
+        indexPath,
         handlerName,
         environment,
         event,
         keepAlive,
         requestId,
+        workingDirectory,
     };
 
     let result;

package/src/invokeHandler.js

@@ -7,23 +7,24 @@ function getDebug(requestId) {
 }
 
 async function invokeHandler({
-    absoluteIndexPath,
+    indexPath,
     handlerName,
     environment,
     event,
     keepAlive = false,
     requestId,
+    workingDirectory,
 }) {
     const id = requestId || generateRequestId();
     const debug = getDebug(id);
 
     const poolRequestId = keepAlive ? undefined : id;
-    const workerPool = await getWorkerPool(absoluteIndexPath, handlerName, environment, poolRequestId);
+    const workerPool = await getWorkerPool(workingDirectory, indexPath, handlerName, environment, poolRequestId);
 
     try {
         debug('Start');
         const result = await workerPool.exec('callHandler', [{
-            absoluteIndexPath,
+            indexPath,
             handlerName,
             event,
             environment: {
@@ -44,7 +45,7 @@ async function invokeHandler({
         throw e;
     } finally {
         if (!keepAlive) {
-            await terminateWorkerPool(absoluteIndexPath, handlerName, poolRequestId);
+            await terminateWorkerPool(workingDirectory, indexPath, handlerName, poolRequestId);
         }
     }
 }

package/src/invokeHandler.spec.js

@@ -23,11 +23,10 @@ describe('invokeHandler', function () {
     });
 
     it('invokes an async handler', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/goodHandler.js');
-
         const result = await invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'goodHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
         });
 
         expect(result).to.be.an('object');
@@ -36,11 +35,10 @@ describe('invokeHandler', function () {
     });
 
     it('invokes a non-async handler', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/goodCallbackHandler.js');
-
         const result = await invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'goodCallbackHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
         });
 
         expect(result).to.be.an('object');
@@ -49,14 +47,14 @@ describe('invokeHandler', function () {
     });
 
     it('invokes the handler with the given event', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/goodHandler.js');
         const event = {
             foo: 'foo',
         };
 
         const result = await invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'goodHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
             event,
         });
 
@@ -70,14 +68,14 @@ describe('invokeHandler', function () {
     });
 
     it('invokes the handler with the given environment variables', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/goodHandler.js');
         const environment = {
             FOO: 'FOO',
         };
 
         const result = await invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'goodHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
             environment,
         });
 
@@ -90,12 +88,12 @@ describe('invokeHandler', function () {
     });
 
     it('rejects when an error is thrown by an async handler', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/badHandler.js');
         const errorMessage = 'FOO';
 
         const invokePromise = invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'badHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
             event: { message: errorMessage },
         });
 
@@ -103,12 +101,12 @@ describe('invokeHandler', function () {
     });
 
     it('rejects when an error is returned by an non-async handler', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/badCallbackHandler.js');
         const errorMessage = 'FOO';
 
         const invokePromise = invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'badCallbackHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
             event: { message: errorMessage },
         });
 
@@ -116,12 +114,12 @@ describe('invokeHandler', function () {
     });
 
     it('rejects when the process dies unexpectedly', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/brokenHandler.js');
         const errorMessage = 'FOO';
 
         const invokePromise = invokeHandler({
-            absoluteIndexPath,
             handlerName: 'handler',
+            indexPath: 'brokenHandler.js',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
             event: { message: errorMessage },
         });
 
@@ -129,12 +127,12 @@ describe('invokeHandler', function () {
     });
 
     it('rejects when the handler function can\'t be found', async function () {
-        const absoluteIndexPath = path.resolve(__dirname, '../tests/assets/goodHandler.js');
         const errorMessage = 'FOO';
 
         const invokePromise = invokeHandler({
-            absoluteIndexPath,
+            indexPath: 'goodHandler.js',
             handlerName: 'foo',
+            workingDirectory: path.resolve(__dirname, '../tests/assets'),
             event: { message: errorMessage },
         });