serverless-offline 8.2.0 → 8.5.0

package/dist/lambda/handler-runner/child-process-runner/childProcessHelper.js

@@ -34,16 +34,7 @@ process.on('message', async messageData => {
   } = messageData; // TODO we could probably cache this in the module scope?
 
   const inProcessRunner = new _index.default(functionKey, handlerPath, handlerName, process.env, timeout, allowCache);
-  let result;
-
-  try {
-    result = await inProcessRunner.run(event, context);
-  } catch (err) {
-    // TODO logging
-    console.log(err);
-    throw err;
-  } // TODO check serializeability (contains function, symbol etc)
-
+  const result = await inProcessRunner.run(event, context); // TODO check serializeability (contains function, symbol etc)
 
   process.send(result);
 });

package/dist/lambda/handler-runner/docker-runner/DockerContainer.js

@@ -49,34 +49,34 @@ const {
   keys
 } = Object;
 
-var _containerId = _classPrivateFieldLooseKey("containerId");
+var _containerId = /*#__PURE__*/_classPrivateFieldLooseKey("containerId");
 
-var _dockerOptions = _classPrivateFieldLooseKey("dockerOptions");
+var _dockerOptions = /*#__PURE__*/_classPrivateFieldLooseKey("dockerOptions");
 
-var _env = _classPrivateFieldLooseKey("env");
+var _env = /*#__PURE__*/_classPrivateFieldLooseKey("env");
 
-var _functionKey = _classPrivateFieldLooseKey("functionKey");
+var _functionKey = /*#__PURE__*/_classPrivateFieldLooseKey("functionKey");
 
-var _handler = _classPrivateFieldLooseKey("handler");
+var _handler = /*#__PURE__*/_classPrivateFieldLooseKey("handler");
 
-var _image = _classPrivateFieldLooseKey("image");
+var _image = /*#__PURE__*/_classPrivateFieldLooseKey("image");
 
-var _imageNameTag = _classPrivateFieldLooseKey("imageNameTag");
+var _imageNameTag = /*#__PURE__*/_classPrivateFieldLooseKey("imageNameTag");
 
-var _lambda = _classPrivateFieldLooseKey("lambda");
+var _lambda = /*#__PURE__*/_classPrivateFieldLooseKey("lambda");
 
-var _layers = _classPrivateFieldLooseKey("layers");
+var _layers = /*#__PURE__*/_classPrivateFieldLooseKey("layers");
 
-var _port = _classPrivateFieldLooseKey("port");
+var _port = /*#__PURE__*/_classPrivateFieldLooseKey("port");
 
-var _provider = _classPrivateFieldLooseKey("provider");
+var _provider = /*#__PURE__*/_classPrivateFieldLooseKey("provider");
 
-var _runtime = _classPrivateFieldLooseKey("runtime");
+var _runtime = /*#__PURE__*/_classPrivateFieldLooseKey("runtime");
 
-var _servicePath = _classPrivateFieldLooseKey("servicePath");
+var _servicePath = /*#__PURE__*/_classPrivateFieldLooseKey("servicePath");
 
 class DockerContainer {
-  constructor(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions) {
+  constructor(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions, v3Utils) {
     Object.defineProperty(this, _containerId, {
       writable: true,
       value: null
@@ -133,12 +133,19 @@ class DockerContainer {
     _classPrivateFieldLooseBase(this, _functionKey)[_functionKey] = functionKey;
     _classPrivateFieldLooseBase(this, _handler)[_handler] = handler;
     _classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag] = this._baseImage(runtime);
-    _classPrivateFieldLooseBase(this, _image)[_image] = new _DockerImage.default(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag]);
+    _classPrivateFieldLooseBase(this, _image)[_image] = new _DockerImage.default(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag], v3Utils);
     _classPrivateFieldLooseBase(this, _runtime)[_runtime] = runtime;
     _classPrivateFieldLooseBase(this, _layers)[_layers] = layers;
     _classPrivateFieldLooseBase(this, _provider)[_provider] = provider;
     _classPrivateFieldLooseBase(this, _servicePath)[_servicePath] = servicePath;
     _classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions] = dockerOptions;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   _baseImage(runtime) {
@@ -147,7 +154,13 @@ class DockerContainer {
 
   async start(codeDir) {
     await _classPrivateFieldLooseBase(this, _image)[_image].pull();
-    (0, _debugLog.default)('Run Docker container...');
+
+    if (this.log) {
+      this.log.debug('Run Docker container...');
+    } else {
+      (0, _debugLog.default)('Run Docker container...');
+    }
+
     let permissions = 'ro';
 
     if (!_classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions].readOnly) {
@@ -160,10 +173,18 @@ class DockerContainer {
     ];
 
     if (_classPrivateFieldLooseBase(this, _layers)[_layers].length > 0) {
-      (0, _serverlessLog.logLayers)(`Found layers, checking provider type`);
+      if (this.log) {
+        this.log.verbose(`Found layers, checking provider type`);
+      } else {
+        (0, _serverlessLog.logLayers)(`Found layers, checking provider type`);
+      }
 
       if (_classPrivateFieldLooseBase(this, _provider)[_provider].name.toLowerCase() !== 'aws') {
-        (0, _serverlessLog.logLayers)(`Provider ${_classPrivateFieldLooseBase(this, _provider)[_provider].name} is Unsupported. Layers are only supported on aws.`);
+        if (this.log) {
+          this.log.warning(`Provider ${_classPrivateFieldLooseBase(this, _provider)[_provider].name} is Unsupported. Layers are only supported on aws.`);
+        } else {
+          (0, _serverlessLog.logLayers)(`Provider ${_classPrivateFieldLooseBase(this, _provider)[_provider].name} is Unsupported. Layers are only supported on aws.`);
+        }
       } else {
         let layerDir = _classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions].layersDir;
 
@@ -174,16 +195,31 @@ class DockerContainer {
         layerDir = (0, _path.join)(layerDir, this._getLayersSha256());
 
         if (await (0, _fsExtra.pathExists)(layerDir)) {
-          (0, _serverlessLog.logLayers)(`Layers already exist for this function. Skipping download.`);
+          if (this.log) {
+            this.log.verbose(`Layers already exist for this function. Skipping download.`);
+          } else {
+            (0, _serverlessLog.logLayers)(`Layers already exist for this function. Skipping download.`);
+          }
         } else {
           const layers = [];
-          (0, _serverlessLog.logLayers)(`Storing layers at ${layerDir}`); // Only initialise if we have layers, we're using AWS, and they don't already exist
+
+          if (this.log) {
+            this.log.verbose(`Storing layers at ${layerDir}`);
+          } else {
+            (0, _serverlessLog.logLayers)(`Storing layers at ${layerDir}`);
+          } // Only initialise if we have layers, we're using AWS, and they don't already exist
+
 
           _classPrivateFieldLooseBase(this, _lambda)[_lambda] = new _awsSdk.Lambda({
             apiVersion: '2015-03-31',
             region: _classPrivateFieldLooseBase(this, _provider)[_provider].region
           });
-          (0, _serverlessLog.logLayers)(`Getting layers`);
+
+          if (this.log) {
+            this.log.verbose(`Getting layers`);
+          } else {
+            (0, _serverlessLog.logLayers)(`Getting layers`);
+          }
 
           for (const layerArn of _classPrivateFieldLooseBase(this, _layers)[_layers]) {
             layers.push(this._downloadLayer(layerArn, layerDir));
@@ -275,66 +311,119 @@ class DockerContainer {
   async _downloadLayer(layerArn, layerDir) {
     const layerName = layerArn.split(':layer:')[1];
     const layerZipFile = `${layerDir}/${layerName}.zip`;
-    (0, _serverlessLog.logLayers)(`[${layerName}] ARN: ${layerArn}`);
+    const layerProgress = this.log && this.progress.get(`layer-${layerName}`);
+
+    if (this.log) {
+      this.log.verbose(`[${layerName}] ARN: ${layerArn}`);
+    } else {
+      (0, _serverlessLog.logLayers)(`[${layerName}] ARN: ${layerArn}`);
+    }
+
     const params = {
       Arn: layerArn
     };
-    (0, _serverlessLog.logLayers)(`[${layerName}] Getting Info`);
-    let layer = null;
 
-    try {
-      layer = await _classPrivateFieldLooseBase(this, _lambda)[_lambda].getLayerVersionByArn(params).promise();
-    } catch (e) {
-      (0, _serverlessLog.logWarning)(`[${layerName}] ${e.code}: ${e.message}`);
-      return;
+    if (this.log) {
+      this.log.verbose(`[${layerName}] Getting Info`);
+      layerProgress.notice(`Retrieving "${layerName}": Getting info`);
+    } else {
+      (0, _serverlessLog.logLayers)(`[${layerName}] Getting Info`);
     }
 
-    if (Object.prototype.hasOwnProperty.call(layer, 'CompatibleRuntimes') && !layer.CompatibleRuntimes.includes(_classPrivateFieldLooseBase(this, _runtime)[_runtime])) {
-      (0, _serverlessLog.logWarning)(`[${layerName}] Layer is not compatible with ${_classPrivateFieldLooseBase(this, _runtime)[_runtime]} runtime`);
-      return;
-    }
+    try {
+      let layer = null;
 
-    const layerUrl = layer.Content.Location; // const layerSha = layer.Content.CodeSha256
+      try {
+        layer = await _classPrivateFieldLooseBase(this, _lambda)[_lambda].getLayerVersionByArn(params).promise();
+      } catch (e) {
+        if (this.log) {
+          this.log.warning(`[${layerName}] ${e.code}: ${e.message}`);
+        } else {
+          (0, _serverlessLog.logWarning)(`[${layerName}] ${e.code}: ${e.message}`);
+        }
 
-    const layerSize = layer.Content.CodeSize;
-    await (0, _fsExtra.ensureDir)(layerDir);
-    (0, _serverlessLog.logLayers)(`[${layerName}] Downloading ${this._formatBytes(layerSize)}...`);
-    const res = await (0, _nodeFetch.default)(layerUrl, {
-      method: 'get'
-    });
+        return;
+      }
 
-    if (!res.ok) {
-      (0, _serverlessLog.logWarning)(`[${layerName}] Failed to fetch from ${layerUrl} with ${res.statusText}`);
-      return;
-    }
+      if (Object.prototype.hasOwnProperty.call(layer, 'CompatibleRuntimes') && !layer.CompatibleRuntimes.includes(_classPrivateFieldLooseBase(this, _runtime)[_runtime])) {
+        if (this.log) {
+          this.log.warning(`[${layerName}] Layer is not compatible with ${_classPrivateFieldLooseBase(this, _runtime)[_runtime]} runtime`);
+        } else {
+          (0, _serverlessLog.logWarning)(`[${layerName}] Layer is not compatible with ${_classPrivateFieldLooseBase(this, _runtime)[_runtime]} runtime`);
+        }
 
-    const fileStream = (0, _fs.createWriteStream)(`${layerZipFile}`);
-    await new Promise((resolve, reject) => {
-      res.body.pipe(fileStream);
-      res.body.on('error', err => {
-        reject(err);
-      });
-      fileStream.on('finish', () => {
-        resolve();
+        return;
+      }
+
+      const layerUrl = layer.Content.Location; // const layerSha = layer.Content.CodeSha256
+
+      const layerSize = layer.Content.CodeSize;
+      await (0, _fsExtra.ensureDir)(layerDir);
+
+      if (this.log) {
+        this.log.verbose(`Retrieving "${layerName}": Downloading ${this._formatBytes(layerSize)}...`);
+        layerProgress.notice(`Retrieving "${layerName}": Downloading ${this._formatBytes(layerSize)}`);
+      } else {
+        (0, _serverlessLog.logLayers)(`[${layerName}] Downloading ${this._formatBytes(layerSize)}...`);
+      }
+
+      const res = await (0, _nodeFetch.default)(layerUrl, {
+        method: 'get'
       });
-    });
-    (0, _serverlessLog.logLayers)(`[${layerName}] Unzipping to .layers directory`);
-    const data = await (0, _fsExtra.readFile)(`${layerZipFile}`);
-    const zip = await _jszip.default.loadAsync(data);
-    await Promise.all(keys(zip.files).map(async filename => {
-      const fileData = await zip.files[filename].async('nodebuffer');
-
-      if (filename.endsWith(_path.sep)) {
-        return Promise.resolve();
+
+      if (!res.ok) {
+        if (this.log) {
+          this.log.warning(`[${layerName}] Failed to fetch from ${layerUrl} with ${res.statusText}`);
+        } else {
+          (0, _serverlessLog.logWarning)(`[${layerName}] Failed to fetch from ${layerUrl} with ${res.statusText}`);
+        }
+
+        return;
       }
 
-      await (0, _fsExtra.ensureDir)((0, _path.join)(layerDir, (0, _path.dirname)(filename)));
-      return (0, _fsExtra.writeFile)((0, _path.join)(layerDir, filename), fileData, {
-        mode: zip.files[filename].unixPermissions
+      const fileStream = (0, _fs.createWriteStream)(`${layerZipFile}`);
+      await new Promise((resolve, reject) => {
+        res.body.pipe(fileStream);
+        res.body.on('error', err => {
+          reject(err);
+        });
+        fileStream.on('finish', () => {
+          resolve();
+        });
       });
-    }));
-    (0, _serverlessLog.logLayers)(`[${layerName}] Removing zip file`);
-    (0, _fs.unlinkSync)(`${layerZipFile}`);
+
+      if (this.log) {
+        this.log.verbose(`Retrieving "${layerName}": Unzipping to .layers directory`);
+        layerProgress.notice(`Retrieving "${layerName}": Unzipping to .layers directory`);
+      } else {
+        (0, _serverlessLog.logLayers)(`[${layerName}] Unzipping to .layers directory`);
+      }
+
+      const data = await (0, _fsExtra.readFile)(`${layerZipFile}`);
+      const zip = await _jszip.default.loadAsync(data);
+      await Promise.all(keys(zip.files).map(async filename => {
+        const fileData = await zip.files[filename].async('nodebuffer');
+
+        if (filename.endsWith(_path.sep)) {
+          return Promise.resolve();
+        }
+
+        await (0, _fsExtra.ensureDir)((0, _path.join)(layerDir, (0, _path.dirname)(filename)));
+        return (0, _fsExtra.writeFile)((0, _path.join)(layerDir, filename), fileData, {
+          mode: zip.files[filename].unixPermissions
+        });
+      }));
+
+      if (this.log) {
+        this.log.verbose(`[${layerName}] Removing zip file`);
+      } else {
+        (0, _serverlessLog.logLayers)(`[${layerName}] Removing zip file`);
+      }
+
+      (0, _fs.unlinkSync)(`${layerZipFile}`);
+    } finally {
+      if (this.log) layerProgress.remove();
+    }
   }
 
   async _getBridgeGatewayIp() {
@@ -346,7 +435,12 @@ class DockerContainer {
         stdout: gateway
       } = await (0, _execa.default)('docker', ['network', 'inspect', 'bridge', '--format', '{{(index .IPAM.Config 0).Gateway}}']));
     } catch (err) {
-      console.error(err.stderr);
+      if (this.log) {
+        this.log.error(err.stderr);
+      } else {
+        console.error(err.stderr);
+      }
+
       throw err;
     }
 
@@ -387,7 +481,12 @@ class DockerContainer {
         await (0, _execa.default)('docker', ['stop', _classPrivateFieldLooseBase(this, _containerId)[_containerId]]);
         await (0, _execa.default)('docker', ['rm', _classPrivateFieldLooseBase(this, _containerId)[_containerId]]);
       } catch (err) {
-        console.error(err.stderr);
+        if (this.log) {
+          this.log.error(err.stderr);
+        } else {
+          console.error(err.stderr);
+        }
+
         throw err;
       }
     }

package/dist/lambda/handler-runner/docker-runner/DockerImage.js

@@ -19,30 +19,46 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _imageNameTag = _classPrivateFieldLooseKey("imageNameTag");
+var _imageNameTag = /*#__PURE__*/_classPrivateFieldLooseKey("imageNameTag");
 
 class DockerImage {
-  constructor(imageNameTag) {
+  constructor(imageNameTag, v3Utils) {
     Object.defineProperty(this, _imageNameTag, {
       writable: true,
       value: null
     });
     _classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag] = imageNameTag;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   static async _pullImage(imageNameTag) {
-    (0, _debugLog.default)(`Downloading base Docker image... (${imageNameTag})`);
+    if (this.log) {
+      this.log.debug(`Downloading base Docker image... (${imageNameTag})`);
+    } else {
+      (0, _debugLog.default)(`Downloading base Docker image... (${imageNameTag})`);
+    }
 
     try {
       await (0, _execa.default)('docker', ['pull', '--disable-content-trust=false', imageNameTag]);
     } catch (err) {
-      console.error(err.stderr);
+      if (this.log) {
+        this.log.error(err.stderr);
+      } else {
+        console.error(err.stderr);
+      }
+
       throw err;
     }
   }
 
   async pull() {
-    return DockerImage._memoizedPull(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag]);
+    return DockerImage._memoizedPull(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag], this.v3Utils);
   }
 
 }

package/dist/lambda/handler-runner/docker-runner/DockerRunner.js

@@ -17,12 +17,12 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _codeDir = _classPrivateFieldLooseKey("codeDir");
+var _codeDir = /*#__PURE__*/_classPrivateFieldLooseKey("codeDir");
 
-var _container = _classPrivateFieldLooseKey("container");
+var _container = /*#__PURE__*/_classPrivateFieldLooseKey("container");
 
 class DockerRunner {
-  constructor(funOptions, env, dockerOptions) {
+  constructor(funOptions, env, dockerOptions, v3Utils) {
     Object.defineProperty(this, _codeDir, {
       writable: true,
       value: null
@@ -46,7 +46,7 @@ class DockerRunner {
       _classPrivateFieldLooseBase(this, _codeDir)[_codeDir] = _classPrivateFieldLooseBase(this, _codeDir)[_codeDir].replace(servicePath, dockerOptions.hostServicePath);
     }
 
-    _classPrivateFieldLooseBase(this, _container)[_container] = new _DockerContainer.default(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions);
+    _classPrivateFieldLooseBase(this, _container)[_container] = new _DockerContainer.default(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions, v3Utils);
   }
 
   cleanup() {

package/dist/lambda/handler-runner/go-runner/GoRunner.js

@@ -0,0 +1,211 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _os = require("os");
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+var _execa = _interopRequireWildcard(require("execa"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
+
+var id = 0;
+
+function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
+
+const {
+  writeFile,
+  readFile,
+  mkdir,
+  rmdir
+} = _fs.promises;
+const {
+  parse,
+  stringify
+} = JSON;
+const {
+  cwd
+} = process;
+const PAYLOAD_IDENTIFIER = 'offline_payload';
+
+var _env = /*#__PURE__*/_classPrivateFieldLooseKey("env");
+
+var _handlerPath = /*#__PURE__*/_classPrivateFieldLooseKey("handlerPath");
+
+var _tmpPath = /*#__PURE__*/_classPrivateFieldLooseKey("tmpPath");
+
+var _tmpFile = /*#__PURE__*/_classPrivateFieldLooseKey("tmpFile");
+
+var _goEnv = /*#__PURE__*/_classPrivateFieldLooseKey("goEnv");
+
+class GoRunner {
+  constructor(funOptions, env, v3Utils) {
+    Object.defineProperty(this, _env, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _handlerPath, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _tmpPath, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _tmpFile, {
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, _goEnv, {
+      writable: true,
+      value: null
+    });
+    const {
+      handlerPath
+    } = funOptions;
+    _classPrivateFieldLooseBase(this, _env)[_env] = env;
+    _classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath] = handlerPath;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    } // Make sure we have the mock-lambda runner
+
+
+    (0, _execa.sync)('go', ['get', 'github.com/icarus-sullivan/mock-lambda@e065469']);
+  }
+
+  async cleanup() {
+    try {
+      await rmdir(_classPrivateFieldLooseBase(this, _tmpPath)[_tmpPath], {
+        recursive: true
+      });
+    } catch (e) {// @ignore
+    }
+
+    _classPrivateFieldLooseBase(this, _tmpFile)[_tmpFile] = null;
+    _classPrivateFieldLooseBase(this, _tmpPath)[_tmpPath] = null;
+  }
+
+  _parsePayload(value) {
+    const log = [];
+    let payload;
+
+    for (const item of value.split(_os.EOL)) {
+      if (item.indexOf(PAYLOAD_IDENTIFIER) === -1) {
+        log.push(item);
+      } else if (item.indexOf(PAYLOAD_IDENTIFIER) !== -1) {
+        try {
+          const {
+            offline_payload: {
+              success,
+              error
+            }
+          } = parse(item);
+
+          if (success) {
+            payload = success;
+          } else if (error) {
+            payload = error;
+          }
+        } catch (err) {// @ignore
+        }
+      }
+    } // Log to console in case engineers want to see the rest of the info
+
+
+    if (this.log) {
+      this.log(log.join(_os.EOL));
+    } else {
+      console.log(log.join(_os.EOL));
+    }
+
+    return payload;
+  }
+
+  async run(event, context) {
+    const {
+      dir
+    } = (0, _path.parse)(_classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath]);
+    const handlerCodeRoot = dir.split(_path.sep).slice(0, -1).join(_path.sep);
+    const handlerCode = await readFile(`${_classPrivateFieldLooseBase(this, _handlerPath)[_handlerPath]}.go`, 'utf8');
+    _classPrivateFieldLooseBase(this, _tmpPath)[_tmpPath] = (0, _path.resolve)(handlerCodeRoot, 'tmp');
+    _classPrivateFieldLooseBase(this, _tmpFile)[_tmpFile] = (0, _path.resolve)(_classPrivateFieldLooseBase(this, _tmpPath)[_tmpPath], 'main.go');
+    const out = handlerCode.replace('"github.com/aws/aws-lambda-go/lambda"', 'lambda "github.com/icarus-sullivan/mock-lambda"');
+
+    try {
+      await mkdir(_classPrivateFieldLooseBase(this, _tmpPath)[_tmpPath], {
+        recursive: true
+      });
+    } catch (e) {// @ignore
+    }
+
+    try {
+      await writeFile(_classPrivateFieldLooseBase(this, _tmpFile)[_tmpFile], out, 'utf8');
+    } catch (e) {// @ignore
+    } // Get go env to run this locally
+
+
+    if (!_classPrivateFieldLooseBase(this, _goEnv)[_goEnv]) {
+      const goEnvResponse = await (0, _execa.default)('go', ['env'], {
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+      const goEnvString = goEnvResponse.stdout || goEnvResponse.stderr;
+      _classPrivateFieldLooseBase(this, _goEnv)[_goEnv] = goEnvString.split(_os.EOL).reduce((a, b) => {
+        const [k, v] = b.split('="'); // eslint-disable-next-line no-param-reassign
+
+        a[k] = v ? v.slice(0, -1) : '';
+        return a;
+      }, {});
+    } // Remove our root, since we want to invoke go relatively
+
+
+    const cwdPath = `${_classPrivateFieldLooseBase(this, _tmpFile)[_tmpFile]}`.replace(`${cwd()}${_path.sep}`, '');
+    const {
+      stdout,
+      stderr
+    } = await (0, _execa.default)(`go`, ['run', cwdPath], {
+      stdio: 'pipe',
+      env: { ..._classPrivateFieldLooseBase(this, _env)[_env],
+        ..._classPrivateFieldLooseBase(this, _goEnv)[_goEnv],
+        AWS_LAMBDA_LOG_GROUP_NAME: context.logGroupName,
+        AWS_LAMBDA_LOG_STREAM_NAME: context.logStreamName,
+        AWS_LAMBDA_FUNCTION_NAME: context.functionName,
+        AWS_LAMBDA_FUNCTION_MEMORY_SIZE: context.memoryLimitInMB,
+        AWS_LAMBDA_FUNCTION_VERSION: context.functionVersion,
+        LAMBDA_EVENT: stringify(event),
+        LAMBDA_TEST_EVENT: `${event}`,
+        LAMBDA_CONTEXT: stringify(context),
+        IS_LAMBDA_AUTHORIZER: event.type === 'REQUEST' || event.type === 'TOKEN',
+        IS_LAMBDA_REQUEST_AUTHORIZER: event.type === 'REQUEST',
+        IS_LAMBDA_TOKEN_AUTHORIZER: event.type === 'TOKEN',
+        PATH: process.env.PATH
+      },
+      encoding: 'utf-8'
+    }); // Clean up after we created the temporary file
+
+    await this.cleanup();
+
+    if (stderr) {
+      return stderr;
+    }
+
+    return this._parsePayload(stdout);
+  }
+
+}
+
+exports.default = GoRunner;

package/dist/lambda/handler-runner/go-runner/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _GoRunner.default;
+  }
+});
+
+var _GoRunner = _interopRequireDefault(require("./GoRunner.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }