@netlify/zip-it-and-ship-it 8.4.2 → 8.6.0

package/README.md

@@ -47,7 +47,7 @@ A directory or a list of directories containing the source files. If a string is
 must exist. If an array of strings is provided, at least one directory must exist.
 
 In Netlify, this directory is the
-["Functions folder"](https://docs.netlify.com/functions/configure-and-deploy/#configure-the-functions-folder).
+["Functions folder"](https://docs.netlify.com/functions/optional-configuration/?fn-language=ts#directory).
 
 A source folder can contain:
 
@@ -279,7 +279,7 @@ import { zipFunction } from '@netlify/zip-it-and-ship-it'
 const archive = await zipFunction('functions/function.js', 'functions-dist')
 ```
 
-This is like [`zipFunctions()`](#zipfunctionssrcfolder-destfolder-options) except it bundles a single Function.
+This is like [`zipFunctions()`](#zipfunctionssrcfolders-destfolder-options) except it bundles a single Function.
 
 The return value is `undefined` if the function is invalid.
 
@@ -315,6 +315,10 @@ Each object has the following properties:
   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`.
 
+- `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.
+
 - `mainFile`: `string`
 
   Absolute path to the Function's main file. If the Function is a Node.js directory, this is its `index.js` or
@@ -330,7 +334,7 @@ Each object has the following properties:
 
 ## listFunctionsFiles(srcFolders)
 
-Like [`listFunctions()`](#listfunctionssrcfolder), except it returns not only the Functions main files, but also all
+Like [`listFunctions()`](#listfunctionssrcfolders-options), except it returns not only the Functions main files, but also all
 their required files. This is much slower.
 
 ```js
@@ -354,7 +358,7 @@ See [feature flags](#feature-flags).
 
 ### Return value
 
-The return value is the same as [`listFunctions()`](#listfunctionssrcfolder) but with the following additional
+The return value is the same as [`listFunctions()`](#listfunctionssrcfolders-options) but with the following additional
 properties.
 
 - `srcFile`: `string`
@@ -367,7 +371,7 @@ properties.
 $ zip-it-and-ship-it srcFolder destFolder
 ```
 
-The CLI performs the same logic as [`zipFunctions()`](#zipfunctionssrcfolder-destfolder-options). The archives are
+The CLI performs the same logic as [`zipFunctions()`](#zipfunctionssrcfolders-destfolder-options). The archives are
 printed on `stdout` as a JSON array.
 
 # Bundling Node.js functions
@@ -425,7 +429,7 @@ These are supplied to each of the entrypoint functions (`zipFunction`, `zipFunct
 `listFunctionsFiles`) as a named parameter called `featureFlags`. It consists of an object where each key is the name of
 a feature flag and the values are Booleans indicating whether each feature flag is enabled or disabled.
 
-The list of all feature flags currently being used can be found [here](src/feature_flags.js).
+The list of all feature flags currently being used can be found [here](src/feature_flags.ts).
 
 # Troubleshooting
 
@@ -464,7 +468,7 @@ In Netlify, this is done by ensuring that the following Node.js versions are the
 - Build-time Node.js version: this defaults to Node `16`, but can be
   [overridden with a `.nvmrc` or `NODE_VERSION` environment variable](https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript).
 - Function runtime Node.js version: this defaults to `nodejs16.x` but can be
-  [overridden with a `AWS_LAMBDA_JS_RUNTIME` environment variable](https://docs.netlify.com/functions/build-with-javascript/#runtime-settings).
+  [overridden with a `AWS_LAMBDA_JS_RUNTIME` environment variable](https://docs.netlify.com/functions/optional-configuration/?fn-language=js#node-js-version-for-runtime-2).
 
 Note that this problem might not apply for Node.js native modules using the [N-API](https://nodejs.org/api/n-api.html).
 

package/dist/feature_flags.js

@@ -16,6 +16,8 @@ export const defaultFlags = {
     project_deploy_configuration_api_use_per_function_configuration_files: false,
     // Output CJS file extension
     zisi_output_cjs_extension: false,
+    // Do not allow ___netlify-entry-point as function or file name
+    zisi_disallow_new_entry_name: false,
 };
 // List of supported flags and their default value.
 export const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/main.d.ts

@@ -11,6 +11,7 @@ export interface ListedFunction {
     runtime: RuntimeType;
     extension: string;
     schedule?: string;
+    displayName?: string;
 }
 type ListedFunctionFile = ListedFunction & {
     srcFile: string;
@@ -18,17 +19,20 @@ type ListedFunctionFile = ListedFunction & {
 interface ListFunctionsOptions {
     basePath?: string;
     config?: Config;
+    configFileDirectories?: string[];
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
+    configFileDirectories?: string[] | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
-export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
+    configFileDirectories?: string[] | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction | undefined>;
-export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
+export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, parseISC, }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;

package/dist/main.js

@@ -6,7 +6,8 @@ import { RuntimeCache } from './utils/cache.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
 export { zipFunction, zipFunctions } from './zip.js';
 const augmentWithISC = async (func) => {
-    // ISC is currently only supported in JavaScript and TypeScript functions.
+    // ISC is currently only supported in JavaScript and TypeScript functions
+    // and only supports scheduled functions.
     if (func.runtime.name !== "js" /* RuntimeType.JAVASCRIPT */) {
         return func;
     }
@@ -14,21 +15,21 @@ const augmentWithISC = async (func) => {
     return { ...func, inSourceConfig };
 };
 // List all Netlify Functions main entry files for a specific directory
-export const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+export const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false, } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
     const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
     const paths = await listFunctionsDirectories(srcFolders);
     const cache = new RuntimeCache();
-    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, featureFlags });
+    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     return augmentedFunctions.map(getListedFunction);
 };
 // Finds a function at a specific path.
-export const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+export const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC = false, } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
     const cache = new RuntimeCache();
-    const func = await getFunctionFromPath(path, { cache, config, featureFlags });
+    const func = await getFunctionFromPath(path, { cache, config, configFileDirectories, featureFlags });
     if (!func) {
         return;
     }
@@ -36,19 +37,26 @@ export const listFunction = async function (path, { featureFlags: inputFeatureFl
     return getListedFunction(augmentedFunction);
 };
 // List all Netlify Functions files for a specific directory
-export const listFunctionsFiles = async function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
+export const listFunctionsFiles = async function (relativeSrcFolders, { basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, parseISC = false, } = {}) {
     const featureFlags = getFlags(inputFeatureFlags);
     const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
     const paths = await listFunctionsDirectories(srcFolders);
     const cache = new RuntimeCache();
-    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, featureFlags });
+    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
     const functions = [...functionsMap.values()];
     const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
     const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
     return listedFunctionsFiles.flat();
 };
 const getListedFunction = function ({ runtime, name, mainFile, extension, config, inSourceConfig, }) {
-    return { name, mainFile, runtime: runtime.name, extension, schedule: inSourceConfig?.schedule ?? config.schedule };
+    return {
+        name,
+        displayName: config.name,
+        mainFile,
+        runtime: runtime.name,
+        extension,
+        schedule: inSourceConfig?.schedule ?? config.schedule,
+    };
 };
 const getListedFunctionFiles = async function (func, options) {
     const srcFiles = await getSrcFiles({ ...func, ...options });

package/dist/runtimes/index.d.ts

@@ -16,9 +16,10 @@ export declare const getFunctionsFromPaths: (paths: string[], { cache, config, c
 /**
  * Gets a list of functions found in a list of paths.
  */
-export declare const getFunctionFromPath: (path: string, { cache, config, featureFlags }: {
+export declare const getFunctionFromPath: (path: string, { cache, config, configFileDirectories, featureFlags, }: {
     cache: RuntimeCache;
     config?: Config | undefined;
+    configFileDirectories?: string[] | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionSource | undefined>;
 export {};

package/dist/runtimes/index.js

@@ -1,8 +1,10 @@
 import { extname, basename } from 'path';
 import { getConfigForFunction } from '../config.js';
 import { defaultFlags } from '../feature_flags.js';
+import { FunctionBundlingUserError } from '../utils/error.js';
 import goRuntime from './go/index.js';
 import jsRuntime from './node/index.js';
+import { ENTRY_FILE_NAME } from './node/utils/entry_file.js';
 import rustRuntime from './rust/index.js';
 /**
  * Finds functions for a list of paths using a specific runtime. The return
@@ -17,15 +19,23 @@ const findFunctionsInRuntime = async function ({ cache, dedupe = false, featureF
     // `srcPath`, so that both functions are returned.
     const key = dedupe ? 'name' : 'srcPath';
     // Augmenting the function objects with additional information.
-    const augmentedFunctions = functions.map((func) => [
-        func[key],
-        {
-            ...func,
-            extension: extname(func.mainFile),
-            filename: basename(func.srcPath),
-            runtime,
-        },
-    ]);
+    const augmentedFunctions = functions.map((func) => {
+        if (featureFlags.zisi_disallow_new_entry_name && func.name === ENTRY_FILE_NAME) {
+            throw new FunctionBundlingUserError(`'${ENTRY_FILE_NAME}' is a reserved word and cannot be used as a function name.`, {
+                functionName: func.name,
+                runtime: runtime.name,
+            });
+        }
+        return [
+            func[key],
+            {
+                ...func,
+                extension: extname(func.mainFile),
+                filename: basename(func.srcPath),
+                runtime,
+            },
+        ];
+    });
     const usedPaths = new Set(augmentedFunctions.map(([path]) => path));
     const remainingPaths = paths.filter((path) => !usedPaths.has(path));
     return { functions: augmentedFunctions, remainingPaths };
@@ -66,11 +76,16 @@ export const getFunctionsFromPaths = async (paths, { cache, config, configFileDi
 /**
  * Gets a list of functions found in a list of paths.
  */
-export const getFunctionFromPath = async (path, { cache, config, featureFlags = defaultFlags }) => {
+export const getFunctionFromPath = async (path, { cache, config, configFileDirectories, featureFlags = defaultFlags, }) => {
     for (const runtime of RUNTIMES) {
         const func = await runtime.findFunctionInPath({ path, cache, featureFlags });
         if (func) {
-            const functionConfig = await getConfigForFunction({ config, func: { ...func, runtime }, featureFlags });
+            const functionConfig = await getConfigForFunction({
+                config,
+                configFileDirectories,
+                func: { ...func, runtime },
+                featureFlags,
+            });
             return {
                 ...func,
                 runtime,

package/dist/runtimes/node/utils/entry_file.d.ts

@@ -1,5 +1,6 @@
 import type { FeatureFlags } from '../../../feature_flags.js';
 import { ModuleFormat } from './module_format.js';
+export declare const ENTRY_FILE_NAME = "___netlify-entry-point";
 export interface EntryFile {
     contents: string;
     filename: string;
@@ -8,8 +9,10 @@ export declare const isNamedLikeEntryFile: (file: string, { basePath, filename,
     basePath: string;
     filename: string;
 }) => boolean;
-export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, mainFile, filename, }: {
+export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, extension, featureFlags, filename, mainFile, }: {
     basePath: string;
+    extension: string;
+    featureFlags: FeatureFlags;
     filename: string;
     mainFile: string;
 }) => boolean;

package/dist/runtimes/node/utils/entry_file.js

@@ -1,6 +1,8 @@
 import { basename, extname, resolve } from 'path';
+import { FunctionBundlingUserError } from '../../../utils/error.js';
 import { getFileExtensionForFormat } from './module_format.js';
 import { normalizeFilePath } from './normalize_path.js';
+export const ENTRY_FILE_NAME = '___netlify-entry-point';
 const getEntryFileContents = (mainPath, moduleFormat) => {
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
     if (moduleFormat === "cjs" /* ModuleFormat.COMMONJS */) {
@@ -17,7 +19,21 @@ export const isNamedLikeEntryFile = (file, { basePath, filename, }) => POSSIBLE_
     return entryFilePath === file;
 });
 // Check if any src file (except the mainFile) is considered an entry file for AWS Lambda
-export const conflictsWithEntryFile = (srcFiles, { basePath, mainFile, filename, }) => srcFiles.some((srcFile) => isNamedLikeEntryFile(srcFile, { basePath, filename }) && srcFile !== mainFile);
+export const conflictsWithEntryFile = (srcFiles, { basePath, extension, featureFlags, filename, mainFile, }) => {
+    let hasConflict = false;
+    srcFiles.forEach((srcFile) => {
+        if (featureFlags.zisi_disallow_new_entry_name && srcFile.includes(ENTRY_FILE_NAME)) {
+            throw new FunctionBundlingUserError(`'${ENTRY_FILE_NAME}' is a reserved word and cannot be used as a file or directory name.`, {
+                functionName: basename(filename, extension),
+                runtime: "js" /* RuntimeType.JAVASCRIPT */,
+            });
+        }
+        if (!hasConflict && isNamedLikeEntryFile(srcFile, { basePath, filename }) && srcFile !== mainFile) {
+            hasConflict = true;
+        }
+    });
+    return hasConflict;
+};
 // Returns the name for the AWS Lambda entry file
 // We do set the handler in AWS Lambda to `<func-name>.handler` and because of
 // this it considers `<func-name>.(c|m)?js` as possible entry-points

package/dist/runtimes/node/utils/zip.js

@@ -53,6 +53,8 @@ const createZipArchive = async function ({ aliases, basePath, cache, destFolder,
     // take.
     const hasEntryFileConflict = conflictsWithEntryFile(srcFiles, {
         basePath,
+        extension,
+        featureFlags,
         filename,
         mainFile,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "8.4.2",
+  "version": "8.6.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",