feat: Make additional function attributes available via functions manifest (#1221)

* feat: pass additional-function-attributes

* chore: make attributes available to functions manifest

* fix: fix linting

* fix: use optional chaining

* fix: add ext

* fix: fix tests

* fix: change internal directory name in constants.ts

* feat: add test for go functions with displayName and from an internal functions folder

* feat: add test for rust functions build from internal folder with displayName property

* feat: add test for nodejs functions build from internal folder with displayName property

* test: figure out windows breakn

* fix: take windows paths into account when checking for internal functions

* test: add unit test for checkIsInternalFunction

* docs: add new return values

* test: move tests into a better fixtures structure

* fix: use unixify for checkIsInternalFunction, config, bundler, module and resolve

* feat: add internalFunctionsFolder option to zipfunctionoptions

* test: fix tests

* test: add test for zipFunction and code to support that as well

* test: change toBeTruthy to toBe(true) and isInternalFunction to internalFunction

* chore: change displayName input to name

* chore: change internalFunction to isInternal

* chore: revert unixify, rename tests and internalFunctionsFolder to internalSrcFolder

* test: revert unixify for module to see if windows test still fails

* Revert "test: revert unixify for module to see if windows test still fails"

This reverts commit b444d1c.

Co-authored-by: khen <30577427+khendrikse@users.noreply.github.com>

Author: jackiewmacharia

README.md

@@ -150,6 +150,10 @@ The following properties are accepted:
   The `[name]` placeholder will be replaced by the name of the function, allowing you to use it to construct the path to
   the target directory.
 
+- `name`
+
+  A name to use when displaying the function in the Netlify UI. Populates the `displayName` property in the functions manifest for the specified function.
+
 #### `featureFlags`
 
 See [feature flags](#feature-flags).
@@ -159,7 +163,7 @@ See [feature flags](#feature-flags).
 - _Type_: `string`
 - _Default value_: `undefined`
 
-Defines the path for a manifest file to be created with the results of the functions bundling. This file is a
+Defines the full path, including the file name, to use for the manifest file that will be created with the functions bundling results. For example, `path/to/manifest.json`. This file is a
 JSON-formatted string with the following properties:
 
 - `functions`: An array with the functions created, in the same format as returned by `zipFunctions`
@@ -172,11 +176,18 @@ JSON-formatted string with the following properties:
 
 #### `parallelLimit`
 
-- _Type_: `number`\
+- _Type_: `number`
 - _Default value_: `5`
 
 Maximum number of functions to bundle at the same time.
 
+#### `internalSrcFolder`
+
+- _Type_: `string`
+- _Default value_: `undefined`
+
+Defines the path to the folder with internal functions. Used to populate a function's `isInternal` property, if its path is within this specified internal functions folder.
+
 ### Return value
 
 This returns a `Promise` resolving to an array of objects describing each archive. Every object has the following
@@ -202,6 +213,14 @@ properties.
 
   The size of the generated archive, in bytes.
 
+- `isInternal` `boolean`
+
+  If the function path has a match with the `internalSrcFolder` property, this boolean will be true.
+
+- `displayName` `string`
+
+  If there was a user-defined configuration object applied to the function, and it had a `name` defined. This will be returned here.
+
 Additionally, the following properties also exist for Node.js functions:
 
 - `bundler`: `string`
@@ -257,7 +276,7 @@ Additionally, the following properties also exist for Node.js functions:
 ```js
 import { zipFunction } from '@netlify/zip-it-and-ship-it'
 
-const archive = await zipFunctions('functions/function.js', 'functions-dist')
+const archive = await zipFunction('functions/function.js', 'functions-dist')
 ```
 
 This is like [`zipFunctions()`](#zipfunctionssrcfolder-destfolder-options) except it bundles a single Function.

src/config.ts

@@ -24,6 +24,7 @@ interface FunctionConfig {
   rustTargetDirectory?: string
   schedule?: string
   zipGo?: boolean
+  name?: string
 
   // Temporary configuration property, only meant to be used by the deploy
   // configuration API. Once we start emitting ESM files for all ESM functions,

src/manifest.ts

@@ -10,6 +10,9 @@ interface ManifestFunction {
   path: string
   runtime: string
   schedule?: string
+  displayName?: string
+  bundler?: string
+  isInternal?: boolean
 }
 
 export interface Manifest {
@@ -36,10 +39,22 @@ export const createManifest = async ({ functions, path }: { functions: FunctionR
   await fs.writeFile(path, JSON.stringify(payload))
 }
 
-const formatFunctionForManifest = ({ mainFile, name, path, runtime, schedule }: FunctionResult): ManifestFunction => ({
+const formatFunctionForManifest = ({
+  mainFile,
+  name,
+  path,
+  runtime,
+  schedule,
+  displayName,
+  bundler,
+  isInternal,
+}: FunctionResult): ManifestFunction => ({
   mainFile,
   name,
   path: resolve(path),
   runtime,
   schedule,
+  displayName,
+  bundler,
+  isInternal,
 })

src/runtimes/go/index.ts

@@ -109,7 +109,16 @@ const processSource = async ({
   }
 }
 
-const zipFunction: ZipFunction = async function ({ config, destFolder, filename, mainFile, srcDir, srcPath, stat }) {
+const zipFunction: ZipFunction = async function ({
+  config,
+  destFolder,
+  filename,
+  mainFile,
+  srcDir,
+  srcPath,
+  stat,
+  isInternal,
+}) {
   const destPath = join(destFolder, filename)
   const isSource = extname(mainFile) === '.go'
 
@@ -151,7 +160,12 @@ const zipFunction: ZipFunction = async function ({ config, destFolder, filename,
     await copyFile(binary.path, destPath)
   }
 
-  return { config, path: destPath }
+  return {
+    config,
+    path: destPath,
+    displayName: config?.name,
+    isInternal,
+  }
 }
 
 const runtime: Runtime = { findFunctionsInPaths, findFunctionInPath, name: RuntimeType.GO, zipFunction }

src/runtimes/node/index.ts

@@ -45,6 +45,7 @@ const zipFunction: ZipFunction = async function ({
   srcDir,
   srcPath,
   stat,
+  isInternal,
 }) {
   const pluginsModulesPath = await getPluginsModulesPath(srcDir)
   const bundlerName = await getBundlerName({
@@ -126,6 +127,8 @@ const zipFunction: ZipFunction = async function ({
     nativeNodeModules,
     nodeModulesWithDynamicImports,
     path: zipPath,
+    displayName: config?.name,
+    isInternal,
   }
 }
 

src/runtimes/runtime.ts

@@ -45,6 +45,8 @@ export interface ZipFunctionResult {
   nativeNodeModules?: object
   nodeModulesWithDynamicImports?: string[]
   path: string
+  isInternal?: boolean
+  displayName?: string
 }
 
 export type ZipFunction = (
@@ -56,6 +58,7 @@ export type ZipFunction = (
     destFolder: string
     featureFlags: FeatureFlags
     repositoryRoot?: string
+    isInternal?: boolean
   } & FunctionSource,
 ) => Promise<ZipFunctionResult>
 

src/runtimes/rust/index.ts

@@ -137,6 +137,7 @@ const zipFunction: ZipFunction = async function ({
   srcDir,
   srcPath,
   stat,
+  isInternal,
 }) {
   const destPath = join(destFolder, `${filename}.zip`)
   const isSource = extname(mainFile) === '.rs'
@@ -157,7 +158,12 @@ const zipFunction: ZipFunction = async function ({
     await zipBinary({ ...zipOptions, srcPath, stat })
   }
 
-  return { config, path: destPath }
+  return {
+    config,
+    path: destPath,
+    displayName: config?.name,
+    isInternal,
+  }
 }
 
 const runtime: Runtime = { findFunctionsInPaths, findFunctionInPath, name: RuntimeType.RUST, zipFunction }

src/zip.ts

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs'
 import { resolve } from 'path'
 
+import isPathInside from 'is-path-inside'
 import pMap from 'p-map'
 
 import { ArchiveFormat } from './archive.js'
@@ -27,12 +28,14 @@ interface ZipFunctionOptions {
   zipGo?: boolean
   systemLog?: LogFunction
   debug?: boolean
+  internalSrcFolder?: string
 }
 
 export type ZipFunctionsOptions = ZipFunctionOptions & {
   configFileDirectories?: string[]
   manifest?: string
   parallelLimit?: number
+  internalSrcFolder?: string
 }
 
 const DEFAULT_PARALLEL_LIMIT = 5
@@ -60,6 +63,7 @@ export const zipFunctions = async function (
     repositoryRoot = basePath,
     systemLog,
     debug,
+    internalSrcFolder,
   }: ZipFunctionsOptions = {},
 ) {
   validateArchiveFormat(archiveFormat)
@@ -68,6 +72,8 @@ export const zipFunctions = async function (
   const cache = new RuntimeCache()
   const featureFlags = getFlags(inputFeatureFlags)
   const srcFolders = resolveFunctionsDirectories(relativeSrcFolders)
+  const internalFunctionsPath = internalSrcFolder && resolve(internalSrcFolder)
+
   const [paths] = await Promise.all([listFunctionsDirectories(srcFolders), fs.mkdir(destFolder, { recursive: true })])
   const functions = await getFunctionsFromPaths(paths, {
     cache,
@@ -104,6 +110,7 @@ export const zipFunctions = async function (
         srcDir: func.srcDir,
         srcPath: func.srcPath,
         stat: func.stat,
+        isInternal: Boolean(internalFunctionsPath && isPathInside(func.srcPath, internalFunctionsPath)),
       })
       const durationNs = endTimer(startIntervalTime)
       const logObject = {
@@ -148,6 +155,7 @@ export const zipFunction = async function (
     repositoryRoot = basePath,
     systemLog,
     debug,
+    internalSrcFolder,
   }: ZipFunctionOptions = {},
 ) {
   validateArchiveFormat(archiveFormat)
@@ -157,6 +165,7 @@ export const zipFunction = async function (
   const srcPath = resolve(relativeSrcPath)
   const cache = new RuntimeCache()
   const functions = await getFunctionsFromPaths([srcPath], { cache, config: inputConfig, dedupe: true, featureFlags })
+  const internalFunctionsPath = internalSrcFolder && resolve(internalSrcFolder)
 
   if (functions.size === 0) {
     return
@@ -199,6 +208,7 @@ export const zipFunction = async function (
     srcDir,
     srcPath,
     stat: stats,
+    isInternal: Boolean(internalFunctionsPath && isPathInside(srcPath, internalFunctionsPath)),
   })
   const durationNs = endTimer(startIntervalTime)
   const logObject = {

tests/fixtures/go-internal/.netlify/internal-functions/go-func-1/main.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println("Hello, world!")
+}

tests/fixtures/go-internal/.netlify/internal-functions/go-func-2/go-func-2.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println("Hello, world!")
+}

tests/fixtures/go-internal/.netlify/internal-functions/go-func-2/go.mod

@@ -0,0 +1,3 @@
+module github.com/netlify/zip-it-and-ship-it/tests/fixtures/go-source
+
+go 1.15

tests/fixtures/go-internal/.netlify/internal-functions/go-func-2/go.sum

@@ -0,0 +1 @@
+module.exports = true

tests/fixtures/node-display-name/function-1.js

@@ -0,0 +1 @@
+module.exports = true

tests/fixtures/node-internal/.netlify/internal-functions/function-1.js

@@ -0,0 +1 @@
+module.exports = true

tests/fixtures/node-internal/.netlify/internal-functions/function-2.js

@@ -0,0 +1 @@
+/target

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-1/.gitignore

@@ -0,0 +1,14 @@
+[package]
+edition = "2018"
+name = "hello"
+version = "0.1.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+aws_lambda_events = "0.5.0"
+http = "0.2.5"
+lambda_runtime = "0.4.1"
+log = "0.4.14"
+simple_logger = "1.13.0"
+tokio = "1.14.0"

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-1/Cargo.lock

@@ -0,0 +1,29 @@
+use aws_lambda_events::event::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse};
+use aws_lambda_events::encodings::Body;
+use http::header::HeaderMap;
+use lambda_runtime::{handler_fn, Context, Error};
+use log::LevelFilter;
+use simple_logger::SimpleLogger;
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    SimpleLogger::new().with_level(LevelFilter::Info).init().unwrap();
+
+    let func = handler_fn(my_handler);
+    lambda_runtime::run(func).await?;
+    Ok(())
+}
+
+pub(crate) async fn my_handler(event: ApiGatewayProxyRequest, _ctx: Context) -> Result<ApiGatewayProxyResponse, Error> {
+    let path = event.path.unwrap();
+
+    let resp = ApiGatewayProxyResponse {
+        status_code: 200,
+        headers: HeaderMap::new(),
+        multi_value_headers: HeaderMap::new(),
+        body: Some(Body::Text(format!("Hello from '{}'", path))),
+        is_base64_encoded: Some(false),
+    };
+
+    Ok(resp)
+}

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-1/Cargo.toml

@@ -0,0 +1 @@
+/target

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-1/src/main.rs

@@ -0,0 +1,14 @@
+[package]
+edition = "2018"
+name = "hello"
+version = "0.1.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+aws_lambda_events = "0.5.0"
+http = "0.2.5"
+lambda_runtime = "0.4.1"
+log = "0.4.14"
+simple_logger = "1.13.0"
+tokio = "1.14.0"

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-2/.gitignore

@@ -0,0 +1,29 @@
+use aws_lambda_events::event::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse};
+use aws_lambda_events::encodings::Body;
+use http::header::HeaderMap;
+use lambda_runtime::{handler_fn, Context, Error};
+use log::LevelFilter;
+use simple_logger::SimpleLogger;
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    SimpleLogger::new().with_level(LevelFilter::Info).init().unwrap();
+
+    let func = handler_fn(my_handler);
+    lambda_runtime::run(func).await?;
+    Ok(())
+}
+
+pub(crate) async fn my_handler(event: ApiGatewayProxyRequest, _ctx: Context) -> Result<ApiGatewayProxyResponse, Error> {
+    let path = event.path.unwrap();
+
+    let resp = ApiGatewayProxyResponse {
+        status_code: 200,
+        headers: HeaderMap::new(),
+        multi_value_headers: HeaderMap::new(),
+        body: Some(Body::Text(format!("Hello from '{}'", path))),
+        is_base64_encoded: Some(false),
+    };
+
+    Ok(resp)
+}

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-2/Cargo.lock

@@ -67,8 +67,29 @@ describe('zip-it-and-ship-it', () => {
     expect(files).toHaveLength(1)
     expect(files[0].runtime).toBe('js')
     expect(files[0].mainFile).toBe(join(FIXTURES_DIR, fixtureName, 'function.js'))
+    expect(files[0].isInternal).toBeFalsy()
   })
 
+  testMany(
+    'Zips Node.js function files from an internal functions dir with a configured name',
+    [...allBundleConfigs, 'bundler_none'],
+    async (options) => {
+      const fixtureName = join('node-internal', '.netlify/internal-functions')
+      const { files } = await zipFixture(fixtureName, {
+        length: 2,
+        opts: {
+          internalSrcFolder: join(FIXTURES_DIR, fixtureName),
+          ...options,
+          config: { 'function-1': { name: 'Function One' } },
+        },
+      })
+      expect(files).toHaveLength(2)
+      expect(files[0].isInternal).toBe(true)
+      expect(files[0].displayName).toBe('Function One')
+      expect(files[1].displayName).toBeUndefined()
+    },
+  )
+
   testMany(
     'Handles Node module with native bindings (buildtime marker module)',
     [...allBundleConfigs],
@@ -1744,6 +1765,32 @@ describe('zip-it-and-ship-it', () => {
     expect(mockSource).toBe(unzippedBinaryContents)
   })
 
+  test('Builds Go functions from an internal functions dir with a configured name', async () => {
+    vi.mocked(shellUtils.runCommand).mockImplementation(async (...args) => {
+      await writeFile(args[1][2], '')
+
+      return {} as any
+    })
+
+    const fixtureName = join('go-internal', '.netlify/internal-functions')
+    const { files } = await zipFixture(fixtureName, {
+      length: 2,
+      opts: {
+        internalSrcFolder: join(FIXTURES_DIR, fixtureName),
+        config: {
+          'go-func-1': {
+            name: 'Go Function One',
+          },
+        },
+      },
+    })
+
+    expect(files).toHaveLength(2)
+    expect(files[0].isInternal).toBe(true)
+    expect(files[0].displayName).toBe('Go Function One')
+    expect(files[1].displayName).toBeUndefined()
+  })
+
   test('Builds Go functions from source', async () => {
     vi.mocked(shellUtils.runCommand).mockImplementation(async (...args) => {
       await writeFile(args[1][2], '')
@@ -1763,13 +1810,15 @@ describe('zip-it-and-ship-it', () => {
         name: 'go-func-1',
         path: expect.anything(),
         runtime: 'go',
+        isInternal: false,
       },
       {
         config: expect.anything(),
         mainFile: join(FIXTURES_DIR, fixtureName, 'go-func-2', 'go-func-2.go'),
         name: 'go-func-2',
         path: expect.anything(),
         runtime: 'go',
+        isInternal: false,
       },
     ])
 
@@ -1870,6 +1919,7 @@ describe('zip-it-and-ship-it', () => {
         path: expect.anything(),
         runtime: 'rs',
         size: 278,
+        isInternal: false,
       },
       {
         config: expect.anything(),
@@ -1878,6 +1928,7 @@ describe('zip-it-and-ship-it', () => {
         path: expect.anything(),
         runtime: 'rs',
         size: 278,
+        isInternal: false,
       },
     ])
 
@@ -1899,6 +1950,43 @@ describe('zip-it-and-ship-it', () => {
     )
   })
 
+  test('Builds Rust functions from an internal functions dir with a configured name', async () => {
+    vi.mocked(shellUtils.runCommand).mockImplementation(async (...args) => {
+      const [rootCommand, , { env: environment }] = args
+
+      if (rootCommand === 'cargo') {
+        const directory = join(environment.CARGO_TARGET_DIR, args[1][2], 'release')
+        const binaryPath = join(directory, 'hello')
+
+        await mkdir(directory, { recursive: true })
+        await writeFile(binaryPath, '')
+
+        return {} as any
+      }
+    })
+
+    const fixtureName = join('rust-internal', '.netlify/internal-functions')
+    const { files } = await zipFixture(fixtureName, {
+      length: 2,
+      opts: {
+        internalSrcFolder: join(FIXTURES_DIR, fixtureName),
+        config: {
+          'rust-func-1': {
+            name: 'Rust Function Two',
+          },
+        },
+        featureFlags: {
+          buildRustSource: true,
+        },
+      },
+    })
+
+    expect(files).toHaveLength(2)
+    expect(files[0].isInternal).toBe(true)
+    expect(files[0].displayName).toBe('Rust Function Two')
+    expect(files[1].displayName).toBeUndefined()
+  })
+
   test('Adds `type: "functionsBundling"` to errors resulting from compiling Rust binaries', async () => {
     vi.mocked(shellUtils.runCommand).mockImplementation((...args) => {
       if (args[0] === 'cargo') {

tests/fixtures/rust-internal/.netlify/internal-functions/rust-func-2/Cargo.toml

@@ -138,4 +138,34 @@ describe('zipFunction', () => {
       expect(mock2).toBe(true)
     },
   )
+
+  testMany(
+    'Can populate the isInternal property for functions',
+    ['bundler_default', 'bundler_esbuild', 'bundler_nft'],
+    async (options) => {
+      const { path: tmpDir } = await getTmpDir({ prefix: 'zip-it-test' })
+      const basePath = join(FIXTURES_DIR, 'node-internal', '.netlify/internal-functions')
+      const opts = merge(options, {
+        internalSrcFolder: basePath,
+      })
+      const result = (await zipFunction(`${basePath}/function-1.js`, tmpDir, opts))!
+
+      expect(result.isInternal).toBe(true)
+    },
+  )
+
+  testMany(
+    'Can populate the displayName property for functions',
+    ['bundler_default', 'bundler_esbuild', 'bundler_nft'],
+    async (options) => {
+      const { path: tmpDir } = await getTmpDir({ prefix: 'zip-it-test' })
+      const basePath = join(FIXTURES_DIR, 'node-display-name')
+      const opts = merge(options, {
+        config: { 'function-1': { name: 'Function One' } },
+      })
+      const result = (await zipFunction(`${basePath}/function-1.js`, tmpDir, opts))!
+
+      expect(result.displayName).toBe('Function One')
+    },
+  )
 })