@swydo/byol 2.1.0 → 2.1.3

package/CHANGELOG.md

@@ -3,12 +3,283 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-# 2.1.0 (2021-09-07)
+## 2.1.3 (2022-04-25)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.1.2 (2022-04-25)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.1.1 (2022-04-25)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+# 2.1.0 (2022-04-22)
 
 
 ### Features
 
-* **byol-cli:** add API Gateway v2 "http" request context param ([#274](https://github.com/Swydo/byol/issues/274)) ([c33e741](https://github.com/Swydo/byol/commit/c33e741296da242faaeaf9d9d0cb3ed8edc4b8de))
+* support `--inspect` to enable attaching a debugger to child processes ([#376](https://github.com/Swydo/byol/issues/376)) ([097d139](https://github.com/Swydo/byol/commit/097d139f1690b64a3a994cd2c4fa44be7a61e49d))
+
+
+
+
+
+## 2.0.36 (2022-04-22)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.35 (2022-04-22)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.34 (2022-04-22)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.33 (2022-04-22)
+
+
+### Bug Fixes
+
+* **deps:** revert dateformat to 4.y.z ([#373](https://github.com/Swydo/byol/issues/373)) ([6ea71d2](https://github.com/Swydo/byol/commit/6ea71d271bf861fe268cb7e370b26d3d8a3dbd73))
+
+
+
+
+
+## 2.0.32 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.31 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.30 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.29 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.28 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.27 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.26 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.25 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.24 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.23 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.22 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.21 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.20 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.19 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.18 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.17 (2022-04-06)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 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
+
+
+
+
+
+## 2.0.12 (2021-10-13)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.11 (2021-10-13)
+
+**Note:** Version bump only for package @swydo/byol
+
+
+
+
+
+## 2.0.10 (2021-09-15)
+
+
+### Bug Fixes
+
+* **byol-cli:** Mismatch between amazon and local api ([#278](https://github.com/Swydo/byol/issues/278)) ([1e40d93](https://github.com/Swydo/byol/commit/1e40d93178203389f9bcfa742b923023f64d0944))
+
+
+
+
+
+## 2.0.9 (2021-09-10)
+
+
+### Bug Fixes
+
+* **byol-cli:** do not stringify body of lambda result ([#275](https://github.com/Swydo/byol/issues/275)) ([38ebcef](https://github.com/Swydo/byol/commit/38ebcefca31e100ada02425771b9dda9600a320f))
+
+
+
+
+
+## 2.0.8 (2021-09-07)
+
+**Note:** Version bump only for package @swydo/byol
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@swydo/byol",
-	"version": "2.1.0",
+	"version": "2.1.3",
 	"description": "Bring Your Own Lambda",
 	"license": "MIT",
 	"engines": {
@@ -22,10 +22,10 @@
 		"yaml-cfn": "^0.3.1"
 	},
 	"devDependencies": {
-		"aws-xray-sdk-core": "3.3.3"
+		"aws-xray-sdk-core": "3.3.5"
 	},
 	"peerDependencies": {
 		"aws-xray-sdk-core": "^3.0.0"
 	},
-	"gitHead": "c33e741296da242faaeaf9d9d0cb3ed8edc4b8de"
+	"gitHead": "8b592173687864c4f6945dbef948e84012f63a02"
 }

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(indexPath, handlerName, requestId, poolOptions) {
     if (requestId) {
-        return `${absoluteIndexPath}:${handlerName}:${requestId}`;
+        return `${indexPath}:${handlerName}:${requestId}:${JSON.stringify(poolOptions)}`;
     }
 
-    return `${absoluteIndexPath}:${handlerName}`;
+    return `${indexPath}:${handlerName}:${JSON.stringify(poolOptions)}`;
 }
 
-function terminateWorkerPool(absoluteIndexPath, handlerName, requestId) {
-    const poolKey = getWorkerPoolKey(absoluteIndexPath, handlerName, requestId);
+function terminateWorkerPool(indexPath, handlerName, requestId, poolOptions) {
+    const poolKey = getWorkerPoolKey(indexPath, handlerName, requestId, poolOptions);
 
     const { pool } = workerPoolMap.get(poolKey);
     const terminationPromise = pool.terminate();
@@ -26,25 +26,34 @@ function terminateWorkerPools() {
     const terminationPromises = [];
 
     workerPoolMap.forEach((pool) => {
-        const { absoluteIndexPath, handlerName, requestId } = pool;
-        terminationPromises.push(terminateWorkerPool(absoluteIndexPath, handlerName, requestId));
+        const {
+            absoluteIndexPath,
+            handlerName,
+            requestId,
+            poolOptions,
+        } = pool;
+        terminationPromises.push(terminateWorkerPool(absoluteIndexPath, handlerName, requestId, poolOptions));
     });
 
     return Promise.all(terminationPromises);
 }
 
-async function getWorkerPool(absoluteIndexPath, handlerName, environment = {}, requestId) {
-    const poolKey = getWorkerPoolKey(absoluteIndexPath, handlerName, requestId);
+async function getWorkerPool(indexPath, handlerName, environment = {}, requestId, poolOptions = {}) {
+    const poolKey = getWorkerPoolKey(indexPath, handlerName, requestId, poolOptions);
 
     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',
+            ...poolOptions,
+        });
 
         workerPoolMap.set(poolKey, {
             pool,
-            absoluteIndexPath,
+            indexPath,
             handlerName,
             environment,
             requestId,
+            poolOptions,
         });
     }
 
@@ -53,7 +62,7 @@ async function getWorkerPool(absoluteIndexPath, handlerName, environment = {}, r
     if (JSON.stringify(poolEnvironment) !== JSON.stringify(environment)) {
         terminateWorkerPool(poolKey);
 
-        return getWorkerPool(absoluteIndexPath, handlerName, environment);
+        return getWorkerPool(indexPath, handlerName, environment, requestId, poolOptions);
     }
 
     return pool;

package/src/invokeFunction.js

@@ -41,10 +41,12 @@ function getAwsEnvironment({ profile, region }) {
 async function invokeFunction(functionName, event, {
     templatePath = path.join(process.cwd(), 'template.yml'),
     envPath = path.join(process.cwd(), 'env.json'),
+    debugPortStart,
     region,
     requestId,
     keepAlive = false,
     profile = 'default',
+    invocationType = 'RequestResponse',
 } = {}) {
     const resource = getFunctionResource(templatePath, functionName);
     const environment = {
@@ -55,36 +57,33 @@ async function invokeFunction(functionName, event, {
         Properties: {
             Handler: handler,
             CodeUri: codeUri = '.',
-            EventInvokeConfig: eventInvokeConfig,
         },
     } = resource;
 
     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,
+        debugPortStart,
         handlerName,
         environment,
         event,
         keepAlive,
         requestId,
+        workingDirectory,
     };
 
     let result;
-    let invocationType;
-
-    if (eventInvokeConfig) {
+    if (invocationType === 'Event') {
         invokeHandler(options);
-        invocationType = 'Event';
     } else {
         result = await invokeHandler(options);
-        invocationType = 'RequestResponse';
     }
 
-    return { result, invocationType };
+    return { result };
 }
 
 module.exports = {

package/src/invokeFunction.spec.js

@@ -28,7 +28,7 @@ describe('invokeFunction', function () {
             foo: 'foo',
         };
 
-        const { result, invocationType } = await invokeFunction(
+        const { result } = await invokeFunction(
             'GoodFunction',
             event,
             { templatePath },
@@ -37,7 +37,6 @@ describe('invokeFunction', function () {
         expect(result).to.be.an('object');
         expect(result).to.have.property('env');
         expect(result).to.have.property('args');
-        expect(invocationType).to.equal('RequestResponse');
     });
 
     it('invokes the non-async function\'s handler', async function () {
@@ -46,7 +45,7 @@ describe('invokeFunction', function () {
             foo: 'foo',
         };
 
-        const { result, invocationType } = await invokeFunction(
+        const { result } = await invokeFunction(
             'GoodCallbackFunction',
             event,
             { templatePath },
@@ -55,7 +54,6 @@ describe('invokeFunction', function () {
         expect(result).to.be.an('object');
         expect(result).to.have.property('env');
         expect(result).to.have.property('args');
-        expect(invocationType).to.equal('RequestResponse');
     });
 
     it('invokes the function\'s handler with the given event', async function () {
@@ -64,7 +62,7 @@ describe('invokeFunction', function () {
             foo: 'foo',
         };
 
-        const { result, invocationType } = await invokeFunction(
+        const { result } = await invokeFunction(
             'GoodFunction',
             event,
             { templatePath },
@@ -73,7 +71,6 @@ describe('invokeFunction', function () {
         expect(result).to.be.an('object');
         expect(result).to.have.property('env');
         expect(result).to.have.property('args');
-        expect(invocationType).to.equal('RequestResponse');
 
         const { args } = result;
         expect(args).to.be.an('array').with.length(2);
@@ -86,7 +83,7 @@ describe('invokeFunction', function () {
             foo: 'foo',
         };
 
-        const { result, invocationType } = await invokeFunction(
+        const { result } = await invokeFunction(
             'GoodFunction',
             event,
             { templatePath },
@@ -95,7 +92,6 @@ describe('invokeFunction', function () {
         expect(result).to.be.an('object');
         expect(result).to.have.property('env');
         expect(result).to.have.property('args');
-        expect(invocationType).to.equal('RequestResponse');
 
         const { args } = result;
         expect(args).to.be.an('array').with.length(2);
@@ -107,7 +103,7 @@ describe('invokeFunction', function () {
         const envPath = path.resolve(__dirname, '../tests/assets/goodEnv.json');
         const event = {};
 
-        const { result, invocationType } = await invokeFunction(
+        const { result } = await invokeFunction(
             'GoodFunction',
             event,
             { templatePath, envPath },
@@ -116,7 +112,6 @@ describe('invokeFunction', function () {
         expect(result).to.be.an('object');
         expect(result).to.have.property('env');
         expect(result).to.have.property('args');
-        expect(invocationType).to.equal('RequestResponse');
 
         const { env } = result;
         expect(env).to.have.property('FOO', 'FOO');
@@ -161,13 +156,13 @@ describe('invokeFunction', function () {
             foo: 'foo',
         };
 
-        const { invocationType } = await invokeFunction(
+        const { result } = await invokeFunction(
             'GoodAcyncFunction',
             event,
-            { templatePath },
+            { templatePath, invocationType: 'Event' },
         );
 
-        expect(invocationType).to.equal('Event');
+        expect(result).to.be.equal(undefined);
     });
 
     it('rejects when an error is thrown by the handler', async function () {

package/src/invokeHandler.js

@@ -7,23 +7,31 @@ function getDebug(requestId) {
 }
 
 async function invokeHandler({
-    absoluteIndexPath,
+    debugPortStart,
+    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 poolOptions = {
+        debugPortStart,
+        forkOpts: {
+            cwd: workingDirectory,
+        },
+    };
+    const workerPool = await getWorkerPool(indexPath, handlerName, environment, poolRequestId, poolOptions);
 
     try {
         debug('Start');
         const result = await workerPool.exec('callHandler', [{
-            absoluteIndexPath,
+            indexPath,
             handlerName,
             event,
             environment: {
@@ -44,7 +52,7 @@ async function invokeHandler({
         throw e;
     } finally {
         if (!keepAlive) {
-            await terminateWorkerPool(absoluteIndexPath, handlerName, poolRequestId);
+            await terminateWorkerPool(indexPath, handlerName, poolRequestId, poolOptions);
         }
     }
 }

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 },
         });