@netlify/zip-it-and-ship-it

What is @netlify/zip-it-and-ship-it?

@netlify/zip-it-and-ship-it is a Node.js library designed to bundle and package functions for deployment on Netlify. It helps in zipping up serverless functions and their dependencies, making it easier to deploy them to Netlify's platform.

What are @netlify/zip-it-and-ship-it's main functionalities?

Bundling Functions

This feature allows you to bundle serverless functions from a source directory and output the bundled files to a target directory. The `zipFunctions` method takes two arguments: the source directory and the output directory.

const { zipFunctions } = require('@netlify/zip-it-and-ship-it');

zipFunctions('src/functions', 'out/functions')
  .then(results => console.log('Functions bundled:', results))
  .catch(error => console.error('Error bundling functions:', error));

Detecting Function Dependencies

This feature helps in detecting the dependencies of the functions in a given directory. The `listFunctions` method takes the source directory as an argument and returns a list of functions along with their dependencies.

const { listFunctions } = require('@netlify/zip-it-and-ship-it');

listFunctions('src/functions')
  .then(results => console.log('Function dependencies:', results))
  .catch(error => console.error('Error listing functions:', error));

Zipping Individual Functions

This feature allows you to zip an individual function file and output it as a zip file. The `zipFunction` method takes two arguments: the path to the function file and the output path for the zip file.

const { zipFunction } = require('@netlify/zip-it-and-ship-it');

zipFunction('src/functions/myFunction.js', 'out/functions/myFunction.zip')
  .then(result => console.log('Function zipped:', result))
  .catch(error => console.error('Error zipping function:', error));

Other packages similar to @netlify/zip-it-and-ship-it

serverless

The Serverless Framework is a comprehensive toolkit for deploying serverless applications. It supports multiple cloud providers and offers extensive functionality for managing serverless functions, including packaging and deployment. Compared to @netlify/zip-it-and-ship-it, Serverless Framework is more feature-rich and supports a wider range of cloud providers.

architect

Architect (or Arc) is a framework for building and deploying serverless applications. It focuses on simplicity and developer experience, offering tools for defining and deploying serverless functions. While Architect provides similar packaging and deployment capabilities, it is more opinionated and tightly integrated with AWS services compared to @netlify/zip-it-and-ship-it.

claudia

Claudia.js is a tool for deploying Node.js projects to AWS Lambda and API Gateway. It simplifies the process of packaging and deploying serverless functions. Claudia.js is more AWS-centric and offers less flexibility in terms of cloud provider support compared to @netlify/zip-it-and-ship-it.

README

zip-it-and-ship-it

Creates Zip archives from Node.js, Go, and Rust programs. Those archives are ready to be uploaded to AWS Lambda.

This library is used under the hood by several Netlify features, including production CI builds, Netlify CLI and the JavaScript client.

Check Netlify documentation for:

• Netlify Functions
• Bundling Functions in the CLI

Installation

npm install @netlify/zip-it-and-ship-it

Usage (Node.js)

zipFunctions(srcFolder, destFolder, options?)

srcFolder: string
destFolder: string
options: object?
Return value: Promise<object[]>

const { zipFunctions } = require('@netlify/zip-it-and-ship-it')

const zipNetlifyFunctions = async function () {
  const archives = await zipFunctions('functions', 'functions-dist')
  return archives
}

Creates Zip archives from Node.js, Go, and Rust programs. Those archives are ready to be uploaded to AWS Lambda.

srcFolder is the source files directory. It must exist. In Netlify, this is the "Functions folder".

srcFolder can contain:

• Sub-directories with a main file called either index.js or {dir}.js where {dir} is the sub-directory name.
• .js files (Node.js)
• .zip archives with Node.js already ready to upload to AWS Lambda.
• Go programs already compiled. If the options.zipGo is true, those are zipped. Otherwise, those are copied as is.
• Rust programs already compiled. These programs are always zipped.

When using Node.js files, only the dependencies required by the main file are bundled, in order to keep the archive as small as possible, which improves the Function runtime performance:

• All files/directories within the same directory (except node_modules) are included
• All the require()'d files are included
• All the require()'d node_modules are included, recursively
• The following modules are never included:
  • @types/* TypeScript definitions
  • aws-sdk
• Temporary files like *~, *.swp, etc. are not included

This is done by parsing the JavaScript source in each Function file, and reading the package.json of each Node module.

destFolder is the directory where each .zip archive should be output. It is created if it does not exist. In Netlify CI, this is an unspecified temporary directory inside the CI machine. In Netlify CLI, this is a .netlify/functions directory in your build directory.

Options

zipGo

Type: boolean
Default value: false

Whether to zip Go files. If false, the Go files are copied as is and the filename remains the same.

parallelLimit

Type: number
Default value: 5

Maximum number of Functions to bundle at the same time.

jsBundler

Type: number
Default value: zisi

The bundler to use when processing JavaScript functions. Possible values: zisi, esbuild, esbuild_zisi.

When the value is esbuild_zisi, esbuild will be used with a fallback to zisi in case of an error.

jsExternalModules

Type: array<string>
Default value: []

List of Node modules to include separately inside a node_modules directory.

Applicable only when jsBundler is esbuild.

jsIgnoredModules

Type: array<string>
Default value: []

List of Node modules to keep out of the bundle.

Applicable only when jsBundler is esbuild.

Return value

This returns a Promise resolving to an array of objects describing each archive. Each object has the following properties.

path

Type: string

Absolute file path to the archive file.

runtime

Type: string

Either "js", "go", or "rs".

zipFunction(srcPath, destFolder, options?)

srcPath: string
destFolder: string
options: object?
Return value: object | undefined

const { zipFunction } = require('@netlify/zip-it-and-ship-it')

const zipNetlifyFunctions = async function () {
  const archive = await zipFunctions('functions/function.js', 'functions-dist')
  return archive
}

This is like zipFunctions() except it bundles a single Function.

The return value is undefined if the Function is invalid.

listFunctions(srcFolder)

srcFolder: string
Return value: Promise<object[]>

Returns the list of Functions to bundle.

const { listFunctions } = require('@netlify/zip-it-and-ship-it')

const listNetlifyFunctions = async function () {
  const functions = await listFunctions('functions/function.js')
  return functions
}

Return value

Each object has the following properties.

name

Type: string

Function's name. This is the one used in the Function URL. For example, if a Function is a myFunc.js regular file, the name is myFunc and the URL is https://{hostname}/.netlify/functions/myFunc.

mainFile

Type: string

Absolute path to the Function's main file. If the Function is a Node.js directory, this is its index.js or {dir}.js file.

runtime

Type: string

Either "js", "go", or "rs".

extension

Type: string

Source file extension. For Node.js, this is either .js or .zip. For Go, this can be anything.

listFunctionsFiles(srcFolder)

srcFolder: string
Return value: Promise<object[]>

Like listFunctions(), except it returns not only the Functions main files, but also all their required files. This is much slower.

const { listFunctionsFiles } = require('@netlify/zip-it-and-ship-it')

const listNetlifyFunctionsFiles = async function () {
  const functions = await listFunctionsFiles('functions/function.js')
  return functions
}

Return value

The return value is the same as listFunctions() but with the following additional properties.

srcFile

Type: string

Absolute file to the source file.

Usage (CLI)

$ zip-it-and-ship-it srcFolder destFolder

The CLI performs the same logic as zipFunctions(). The archives are printed on stdout as a JSON array.

The following options are available:

• --zip-go: see the zipGo option

Troubleshooting

Build step

zip-it-and-ship-it does not build, transpile nor install the dependencies of the Functions. This needs to be done before calling zip-it-and-ship-it.

Missing dependencies

If a Node module require() another Node module but does not list it in its package.json (dependencies, peerDependencies or optionalDependencies), it is not bundled, which might make the Function fail.

More information in this issue.

Conditional require

Files required with a require() statement inside an if or try/catch block are always bundled.

More information in this issue.

Dynamic require

Files required with a require() statement whose argument is not a string literal, e.g. require(variable), are never bundled.

More information in this issue.

Node.js native modules

If your Function or one of its dependencies uses Node.js native modules, the Node.js version used in AWS Lambda might need to be the same as the one used when installing those native modules.

In Netlify, this is done by ensuring that the following Node.js versions are the same:

• Build-time Node.js version: this defaults to Node 10, but can be overridden with a .nvmrc or NODE_VERSION environment variable.
• Function runtime Node.js version: this defaults to nodejs12.x but can be overriden with a AWS_LAMBDA_JS_RUNTIME environment variable.

Note that this problem might not apply for Node.js native modules using the N-API.

More information in this issue.

File Serving

As of v0.3.0 the serveFunctions capability has been extracted out to Netlify Dev.