serverless-plugin-go 0.0.1

package/.cz.toml

@@ -0,0 +1,15 @@
+[tool]
+[tool.commitizen]
+name = "cz_customize"
+version = "0.0.1"
+tag_format = "v$version"
+bump_message = "bump: release $current_version → $new_version [skip-ci]"
+update_changelog_on_bump = true
+version_files = [
+    "package.json:version",
+]
+
+[tool.commitizen.customize]
+schema_pattern = "(break|build|ci|docs|feat|fix|perf|refactor|style|test|chore|revert|bump|deps)(\\(\\S+\\))?!?:(\\s.*)"
+bump_pattern = "^(break|build|feat|fix|refactor|style|test|revert|deps|docs|ci|chore)"
+bump_map = {"break" = "MAJOR", "build" = "MINOR", "feat" = "MINOR", "revert" = "MINOR", "fix" = "PATCH", "refactor" = "PATCH", "style" = "PATCH", "test" = "PATCH", "ci" = "PATCH", "deps" = "PATCH", "chore" = "PATCH", "docs" = "PATCH"}

package/.eslintrc.json

@@ -0,0 +1,19 @@
+{
+  "extends": [
+    "plugin:prettier/recommended"
+  ],
+  "plugins": [
+    "prettier"
+  ],
+  "rules": {
+    "prettier/prettier": "error"
+  },
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "env": {
+    "es6": true,
+    "node": true
+  }
+}

package/.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: https://github.com/pre-commit/mirrors-eslint
+    rev: v8.50.0
+    hooks:
+      - id: eslint
+        files: \.[jt]sx?$ # *.js, *.jsx, *.ts and *.tsx
+        types: [file]
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: 3.10.0
+    hooks:
+      - id: commitizen
+        stages: [commit-msg]

package/.prettierignore

@@ -0,0 +1,4 @@
+# Ignore artifacts:
+build/
+coverage/
+node_modules/

package/.prettierrc.json

@@ -0,0 +1 @@
+{}

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+## v0.0.1 (2023-10-26)
+
+
+- chore: enable release pipeline (#5)
+- chore: add debug logs (#4)
+- chore: add start compilation logs (#3)
+- fix: missing system env vars to execute comp[ilation command (#2)
+- chore: first commit

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Maciej Winnicki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# ⚡️Serverless Framework Go Plugin
+
+[![npm](https://img.shields.io/npm/v/serverless-plugin-go)](https://www.npmjs.com/package/serverless-plugin-go)
+
+`serverless-plugin-go` is a Serverless Framework plugin that compiles Go functions on the fly. You don't need to do it manually before `serverless deploy`. Once the plugin is installed it will happen automatically.
+
+## Features
+
+- Concurrent compilation happens across all CPU cores.
+- Support for both `serverless deploy` and `serverless deploy function` commands.
+- Support for `serverless invoke local` command.
+- Additional command `serverless go build`.
+
+## Install
+
+1. Install the plugin
+
+    ```bash
+    npm i --save-dev serverless-plugin-go
+    ```
+
+1. Add it to your `serverless.yaml`
+
+    ```yaml
+    plugins:
+      - 'serverless-plugin-go'
+    ```
+
+1. Replace every Go function's `handler` with `*.go` file path or a package path. E.g.
+
+    ```yaml
+    functions:
+      example:
+        runtime: 'provided.al2'
+        handler: 'functions/example/main.go' # or just functions/example
+    ```
+
+## Configuration
+
+Default values:
+
+```yaml
+custom:
+  go:
+    baseDir: '.' # folder where go.mod file lives, if set `handler` property should be set relatively to that folder
+    binDir: '.bin' # target folder for binary files
+    cmd: 'go build -ldflags="-s -w"' # compile command
+    monorepo: false # if enabled, builds function every directory (useful for monorepo where go.mod is managed by each function
+    env: # environment variables used to compile binaries
+      GOOS: 'linux' # Default compile OS
+      CGO_ENABLED: '0' # By default CGO is disabled
+```
+
+### How does it work?
+
+The plugin compiles every Go function defined in `serverless.yaml` into `.bin` directory. After that it internally changes `handler` so
+that the Serverless Framework will deploy the compiled file not the source file.
+
+For every matched function it also overrides `package` parameter to the next config:
+
+```yaml
+individually: true
+artifact: <path to the generated zip with go binary>
+```
+
+### How to run Golang Lambda on ARM?
+
+Change architecture field from `provider` or function configuration to `arm64`:
+
+```yaml
+provider:
+  architecture: 'arm64'
+  runtime: 'provided.al2'
+
+# If you define architecture at function level, this will have preference instead the provider configuration
+
+functions:
+  test:
+    architecture: 'arm64'
+    handler: test/main.go
+```
+
+## Caveats
+
+This implementation doesn't allow to add any other files to the lambda artifact apart from the binary. To address this problem you should
+use Lambda Layers to allow your lambdas to hold external files.
+
+## Credits
+
+This repo is forked from [serverless-go-plugin][1] created by [mthenw][2] and modified to fix some issues and reach the new AWS standards
+(go1.x provider deprecation).
+
+[1]: https://github.com/mthenw/serverless-go-plugin
+[2]: https://github.com/mthenw

package/index.js

@@ -0,0 +1,316 @@
+import util from "util";
+import cp from "child_process";
+import prettyHrtime from "pretty-hrtime";
+import chalk from "chalk";
+import path from "path";
+import AdmZip from "adm-zip";
+import { readFileSync } from "fs";
+
+// SupportedRuntimes Runtimes that are allowed to run Golang lambdas.
+const supportedRuntimes = ["provided.al2"];
+
+const logPrefix = "GoPlugin";
+
+export default class Go {
+  constructor(serverless, options) {
+    this.readFileSync = readFileSync;
+    this.zip = new AdmZip();
+    this.exec = util.promisify(cp.exec);
+
+    this.serverless = serverless;
+    this.options = options || {};
+
+    this.defaultConfig = {
+      baseDir: ".",
+      binDir: ".bin",
+      env: {
+        CGO_ENABLED: "0",
+        GOOS: "linux",
+      },
+      cmd: 'go build -ldflags="-s -w"',
+      monorepo: false,
+    };
+
+    this.hooks = {
+      "before:deploy:function:packageFunction": this.compileFunction.bind(this),
+      "before:package:createDeploymentArtifacts":
+        this.compileFunctions.bind(this),
+      // Because of https://github.com/serverless/serverless/blob/master/lib/plugins/aws/invokeLocal/index.js#L361
+      // plugin needs to compile a function and then ignore packaging.
+      "before:invoke:local:invoke": this.compileToInvoke.bind(this),
+      "go:build:build": this.compileFunctions.bind(this),
+    };
+
+    this.commands = {
+      go: {
+        usage: "Manage Go functions",
+        lifecycleEvents: ["go"],
+        commands: {
+          build: {
+            usage: "Build all Go functions",
+            lifecycleEvents: ["build"],
+          },
+        },
+      },
+    };
+  }
+
+  /**
+   * Execute single function compilation and package.
+   */
+  async compileFunction() {
+    const name = this.options.function;
+    const func = this.serverless.service.functions[this.options.function];
+
+    this.logInfo(`Starting compilation...`);
+
+    const timeStart = process.hrtime();
+    await this.compile(name, func);
+    const timeEnd = process.hrtime(timeStart);
+
+    this.logInfo(`Compilation time (${name}): ${prettyHrtime(timeEnd)}`);
+  }
+
+  /**
+   * Load all configured functions and execute compilation according it's configuration.
+   */
+  async compileFunctions() {
+    let names = Object.keys(this.serverless.service.functions);
+
+    this.logInfo(`Starting compilation...`);
+
+    const timeStart = process.hrtime();
+
+    let compiles = [];
+
+    for (let funcName of names) {
+      const func = this.serverless.service.functions[funcName];
+      compiles.push(this.compile(funcName, func));
+    }
+
+    await Promise.all(compiles);
+
+    const timeEnd = process.hrtime(timeStart);
+
+    this.logInfo(`Compilation time: ${prettyHrtime(timeEnd)}`);
+  }
+
+  /**
+   * Execute single function compilation and do not create the final artifact.
+   * This is used when `invoke` command is performed.
+   */
+  async compileToInvoke() {
+    const name = this.options.function;
+    const func = this.serverless.service.functions[this.options.function];
+
+    this.logInfo(`Starting compilation...`);
+
+    const timeStart = process.hrtime();
+    await this.compile(name, func, false);
+    const timeEnd = process.hrtime(timeStart);
+
+    this.logInfo(`Compilation time (${name}): ${prettyHrtime(timeEnd)}`);
+  }
+
+  /**
+   * Collect configuration to build binaries and create the final artifact if needed
+   *
+   * @param {string} name name of the node function
+   * @param {Object} func function configuration object
+   * @param {bool} artifact flag to create or not the final artifact
+   *
+   * @throws {Error} if compilation command fails
+   */
+  async compile(name, func, artifact = true) {
+    const config = this.getConfig();
+    const arch = this.getFunctionArch(name);
+    const runtime = this.getFunctionRuntime(name);
+
+    if (!supportedRuntimes.includes(runtime)) {
+      return;
+    }
+
+    if (arch == "arm64") {
+      config.env["GOARCH"] = "arm64";
+    }
+
+    const absHandler = path.resolve(config.baseDir);
+    const absBin = path.resolve(config.binDir);
+
+    let compileBinPath = path.join(path.relative(absHandler, absBin), name); // binPath is based on cwd no baseDir
+    let cwd = config.baseDir;
+    let handler = func.handler;
+
+    if (config.monorepo) {
+      cwd = path.relative(absHandler, func.handler);
+      handler = ".";
+
+      if (func.handler.endsWith(".go")) {
+        cwd = path.relative(absHandler, path.dirname(func.handler));
+        handler = path.basename(func.handler);
+      }
+
+      compileBinPath = path.relative(cwd, compileBinPath);
+    }
+
+    this.logDebug(`[${name}] env: ${JSON.stringify(config.env)}`);
+    this.logDebug(`[${name}] cwd: ${cwd}`);
+    this.logDebug(`[${name}] arch: ${arch}`);
+
+    await this.execCompilation(
+      config.cmd,
+      compileBinPath,
+      handler,
+      cwd,
+      config.env,
+      arch,
+    );
+
+    this.logInfo(`Compiled function: ${chalk.magenta(name)}`);
+
+    let binPath = path.join(config.binDir, name);
+
+    if (process.platform === "win32") {
+      binPath = binPath.replace(/\\/g, "/");
+    }
+
+    this.serverless.service.functions[name].handler = binPath;
+
+    if (artifact) {
+      this.packageBootstrap(name, binPath);
+    }
+  }
+
+  /**
+   * Execute compilation command from collected configuration.
+   *
+   * @param {string} cmd Compilation command
+   * @param {string} out Binary out path
+   * @param {string} main Path to the main package or file
+   * @param {string} cwd Working directory
+   * @param {Object} env Set of environment variables to execute compilation
+   * @param {string} arch Compilation architecture
+   */
+  async execCompilation(cmd, out, main, cwd, env, arch) {
+    let command = `${cmd} -o ${out} ${main}`;
+
+    let execOpts = { cwd: cwd, env: { ...process.env, ...env } };
+
+    try {
+      await this.exec(command, execOpts);
+    } catch (e) {
+      this.logError(`Error compiling function (cwd: ${cwd}): ${e.message}`);
+
+      throw new Error(`error compiling function (cwd: ${cwd})`);
+    }
+  }
+
+  /**
+   * Create package to deploy lambda
+   *
+   * @param {string} name Name of the function config
+   * @param {Object} baseConfig Configuration object
+   * @param {string} binPath Path to generated binary
+   */
+  packageBootstrap(name, binPath) {
+    this.zip.addFile("bootstrap", this.readFileSync(binPath), "", 0o755);
+
+    const zipPath = binPath + ".zip";
+    this.zip.writeZip(zipPath);
+
+    this.serverless.service.functions[name].package = {
+      individually: true,
+      artifact: zipPath,
+    };
+  }
+
+  /**
+   * Merge default con
+   * @returns {Object}
+   */
+  getConfig() {
+    let config = { ...this.defaultConfig };
+    const service = this.serverless.service;
+
+    if (service.custom && service.custom.go) {
+      config = { ...config, ...service.custom.go };
+    }
+
+    for (let env of Object.keys(config.env)) {
+      config.env[env] = `${config.env[env]}`;
+    }
+
+    return config;
+  }
+
+  /**
+   * Read provider and function configuration and return the compilation architecture
+   *
+   * @param {string} funcName Function name to get compilation architecture.
+   *
+   * @returns Architecture name
+   */
+  getFunctionArch(funcName) {
+    const funcConf = this.serverless.service.functions[funcName];
+    const provider = this.serverless.service.provider;
+
+    let arch = provider.architecture || "x86_64";
+
+    if (funcConf.architecture) {
+      arch = funcConf.architecture;
+    }
+
+    return arch;
+  }
+
+  /**
+   * Check provider and function architecture and determine the compilation arch
+   *
+   * @param {string} funcName Function name to collect architecture
+   *
+   * @returns architecture name
+   */
+  getFunctionRuntime(funcName) {
+    const funcConf = this.serverless.service.functions[funcName];
+    const provider = this.serverless.service.provider;
+
+    let runtime = provider.runtime;
+
+    if (funcConf.runtime) {
+      runtime = funcConf.runtime;
+    }
+
+    return runtime;
+  }
+
+  /**
+   * Print a plugin debug log message
+   *
+   * @param {string} message Log message
+   */
+  logDebug(message) {
+    if (!this.options.verbose) {
+      return;
+    }
+
+    this.serverless.cli.consoleLog(`${chalk.yellow(logPrefix)}: ${message}`);
+  }
+
+  /**
+   * Print a plugin info log message
+   *
+   * @param {string} message Log message
+   */
+  logInfo(message) {
+    this.serverless.cli.consoleLog(`${chalk.cyan(logPrefix)}: ${message}`);
+  }
+
+  /**
+   * Print a plugin error log message
+   *
+   * @param {string} message Log message
+   */
+  logError(message) {
+    this.serverless.cli.consoleLog(`${chalk.red(logPrefix)}: ${message}`);
+  }
+}

package/index.test.js

@@ -0,0 +1,349 @@
+import sinon from "sinon";
+import chai from "chai";
+import sinonChai from "sinon-chai";
+
+import Go from "./index.js";
+import ServerlessMock from "./mocks/serverless.mock.js";
+
+const expect = chai.expect;
+
+chai.use(sinonChai);
+
+describe("Go Plugin", () => {
+  let config = new ServerlessMock();
+  let sandbox;
+  let execStub;
+  let readFileSyncStub;
+  let admZipStub;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+    execStub = sandbox.stub().resolves({ stdin: null, stdout: null });
+    readFileSyncStub = sinon
+      .stub()
+      .withArgs(".bin/testFunc1")
+      .returns("fake binary content");
+
+    admZipStub = {
+      addFile: sinon.stub(),
+      writeZip: sinon.stub(),
+    };
+  });
+
+  afterEach(() => {
+    config.service.restore();
+    sandbox.restore();
+  });
+
+  it("Compiles only Go functions with allowed providers", async () => {
+    config.service.setFunctions({
+      testFunc1: {
+        name: "testFunc1",
+        runtime: "nodejs10.x",
+        handler: "functions/func1",
+      },
+      testFunc2: {
+        name: "testFunc2",
+        runtime: "provided.al2",
+        handler: "functions/func2/main.go",
+      },
+      testFunc3: {
+        name: "testFunc3",
+        runtime: "provided.al2",
+        handler: "functions/func3",
+      },
+      testFunc4: {
+        name: "testFunc4",
+        runtime: "go1.x",
+        handler: "functions/func4",
+      },
+    });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.compileFunctions();
+
+    // then
+    expect(config.service.functions.testFunc2.handler).to.equal(
+      `.bin/testFunc2`,
+    );
+
+    expect(execStub).to.have.been.calledWith(
+      `go build -ldflags="-s -w" -o .bin/testFunc2 functions/func2/main.go`,
+      {
+        cwd: ".",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+
+    expect(config.service.functions.testFunc3.handler).to.equal(
+      `.bin/testFunc3`,
+    );
+
+    expect(execStub).to.have.been.calledWith(
+      `go build -ldflags="-s -w" -o .bin/testFunc3 functions/func3`,
+      {
+        cwd: ".",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+  });
+
+  it("Compiles Go function with custom command", async () => {
+    config.service
+      .setCustom({
+        go: {
+          cmd: "go build",
+        },
+      })
+      .setFunctions({
+        testFunc1: {
+          name: "testFunc1",
+          runtime: "provided.al2",
+          handler: "functions/func1/main.go",
+        },
+      });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.compileFunctions();
+
+    // then
+    expect(execStub).to.have.been.calledOnceWith(
+      `go build -o .bin/testFunc1 functions/func1/main.go`,
+      {
+        cwd: ".",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+  });
+
+  it("Compiles Go function with arm architecture", async () => {
+    config.service
+      .setProvider({
+        architecture: "arm64",
+      })
+      .setFunctions({
+        testFunc1: {
+          name: "testFunc1",
+          runtime: "provided.al2",
+          handler: "functions/func1/main.go",
+        },
+      });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.compileFunctions();
+
+    // then
+    expect(execStub).to.have.been.calledOnceWith(
+      `go build -ldflags="-s -w" -o .bin/testFunc1 functions/func1/main.go`,
+      {
+        cwd: ".",
+        env: {
+          ...process.env,
+          ...{ CGO_ENABLED: "0", GOOS: "linux", GOARCH: "arm64" },
+        },
+      },
+    );
+  });
+
+  it("Compiles Go function with custom base dir", async () => {
+    config.service
+      .setCustom({
+        go: {
+          baseDir: "gopath",
+        },
+      })
+      .setFunctions({
+        testFunc1: {
+          name: "testFunc1",
+          runtime: "provided.al2",
+          handler: "functions/func1/main.go",
+        },
+      });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.compileFunctions();
+
+    // then
+    expect(execStub).to.have.been.calledOnceWith(
+      `go build -ldflags="-s -w" -o ../.bin/testFunc1 functions/func1/main.go`,
+      {
+        cwd: "gopath",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+  });
+
+  it("Throw error if compilation fails", async () => {
+    execStub.throws();
+
+    config.service.setFunctions({
+      testFunc1: {
+        name: "testFunc1",
+        runtime: "provided.al2",
+        handler: "functions/func1/main.go",
+      },
+    });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    try {
+      await plugin.compileFunctions();
+    } catch (e) {
+      expect(e.message).to.equal(`error compiling function (cwd: .)`);
+      return;
+    }
+
+    expect.fail("Expected to throw an Error");
+  });
+
+  it("Compiles Go function with global runtime defined", async () => {
+    config.service
+      .setProvider({
+        runtime: "provided.al2",
+      })
+      .setFunctions({
+        testFunc1: {
+          name: "testFunc1",
+          handler: "functions/func1/main.go",
+        },
+      });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.hooks["before:package:createDeploymentArtifacts"]();
+
+    // then
+    expect(execStub).to.have.been.calledOnce;
+  });
+
+  it("Compiles single Go function", async () => {
+    config.service.setFunctions({
+      testFunc1: {
+        name: "testFunc1",
+        runtime: "provided.al2",
+        handler: "functions/func1/main.go",
+      },
+    });
+
+    const plugin = new Go(config, { function: "testFunc1" });
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.hooks["before:deploy:function:packageFunction"]();
+
+    // then
+    expect(execStub).to.have.been.calledOnceWith(
+      `go build -ldflags="-s -w" -o .bin/testFunc1 functions/func1/main.go`,
+      {
+        cwd: ".",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+  });
+
+  it("Compiles Go function with monorepo", async () => {
+    config.service
+      .setCustom({
+        go: {
+          monorepo: true,
+        },
+      })
+      .setFunctions({
+        testFunc1: {
+          name: "testFunc1",
+          runtime: "provided.al2",
+          handler: "functions/func1",
+        },
+        testFunc2: {
+          name: "testFunc2",
+          runtime: "provided.al2",
+          handler: "functions/func2/main.go",
+        },
+      });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.hooks["before:package:createDeploymentArtifacts"]();
+
+    // then
+    expect(config.service.functions.testFunc1.handler).to.equal(
+      `.bin/testFunc1`,
+    );
+
+    expect(execStub).to.have.been.calledWith(
+      `go build -ldflags="-s -w" -o ../../.bin/testFunc1 .`,
+      {
+        cwd: "functions/func1",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+
+    expect(config.service.functions.testFunc2.handler).to.equal(
+      `.bin/testFunc2`,
+    );
+
+    expect(execStub).to.have.been.calledWith(
+      `go build -ldflags="-s -w" -o ../../.bin/testFunc2 main.go`,
+      {
+        cwd: "functions/func2",
+        env: { ...process.env, ...{ CGO_ENABLED: "0", GOOS: "linux" } },
+      },
+    );
+  });
+
+  it("compiles Go functions", async () => {
+    config.service.setFunctions({
+      testFunc1: {
+        name: "testFunc1",
+        runtime: "provided.al2",
+        handler: "functions/func2/main.go",
+      },
+    });
+
+    const plugin = new Go(config);
+    plugin.exec = execStub;
+    plugin.readFileSync = readFileSyncStub;
+    plugin.zip = admZipStub;
+
+    // when
+    await plugin.hooks["go:build:build"]();
+
+    // then
+    expect(config.service.functions.testFunc1.handler).to.equal(
+      `.bin/testFunc1`,
+    );
+  });
+});

package/mocks/serverless.mock.js

@@ -0,0 +1,17 @@
+import sinon from "sinon";
+
+import ServiceMock from "./service.mock.js";
+
+export default class ServerlessMock {
+  constructor() {
+    this.service = new ServiceMock();
+
+    this.cli = {
+      consoleLog: sinon.stub(),
+    };
+  }
+
+  getProvider() {
+    return {};
+  }
+}

package/mocks/service.mock.js

@@ -0,0 +1,36 @@
+export default class ServiceMock {
+  constructor() {
+    this.custom = {};
+    this.functions = {};
+    this.provider = {};
+  }
+
+  setFunctions(functions) {
+    this.functions = functions;
+    return this;
+  }
+
+  setCustom(custom) {
+    this.custom = custom;
+    return this;
+  }
+
+  setProvider(provider) {
+    this.provider = provider;
+    return this;
+  }
+
+  getAllFunctions() {
+    return Object.keys(this.functions);
+  }
+
+  getFunction(name) {
+    return this.functions[name];
+  }
+
+  restore() {
+    this.custom = {};
+    this.functions = {};
+    this.provider = {};
+  }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "serverless-plugin-go",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Serverless Framework plugin that compiles Go functions on the fly",
+  "main": "index.js",
+  "scripts": {
+    "lint": "npx eslint --fix .",
+    "format": "npx prettier --write .",
+    "test": "npx mocha index.test.js",
+    "depsUpgrade": "node ./scripts/updateDeps.cjs",
+    "pre-commit": "pre-commit install --hook-type commit-msg"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Drafteame/serverless-plugin-go.git"
+  },
+  "keywords": [
+    "serverless",
+    "serverless framework",
+    "serverless plugin",
+    "amazon web services",
+    "aws",
+    "lambda",
+    "golang",
+    "go"
+  ],
+  "author": "Maciej Winnicki <maciej.winnicki@gmail.com>",
+  "contributors": [
+    {
+      "name": "Eduardo Aguilar",
+      "email": "dante.aguilar41@gmail.com",
+      "url": "https://github.com/danteay"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Drafteame/serverless-plugin-go/issues"
+  },
+  "homepage": "https://github.com/Drafteame/serverless-plugin-go#readme",
+  "dependencies": {
+    "adm-zip": "^0.5.10",
+    "chalk": "^5.3.0",
+    "pretty-hrtime": "^1.0.3",
+    "util": "^0.12.5"
+  },
+  "devDependencies": {
+    "chai": "^4.3.10",
+    "child_process": "^1.0.2",
+    "eslint": "^8.52.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "fs": "^0.0.1-security",
+    "mocha": "^10.2.0",
+    "prettier": "^3.0.3",
+    "sinon": "^17.0.0",
+    "sinon-chai": "^3.7.0"
+  }
+}