@netlify/zip-it-and-ship-it 8.2.0 → 8.4.0

package/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.

package/dist/config.d.ts

@@ -15,6 +15,7 @@ interface FunctionConfig {
     rustTargetDirectory?: string;
     schedule?: string;
     zipGo?: boolean;
+    name?: string;
     nodeModuleFormat?: ModuleFormat;
 }
 type GlobPattern = string;

package/dist/feature_flags.js

@@ -14,12 +14,8 @@ export const defaultFlags = {
     zisi_pure_esm_mjs: false,
     // Load configuration from per-function JSON files.
     project_deploy_configuration_api_use_per_function_configuration_files: false,
-    // Enable runtime cache for NFT
-    zisi_nft_use_cache: false,
-    // Raise file IO limit for NFT
-    zisi_nft_higher_fileio_limit: false,
-    // Provide banner to esbuild which allows requires in ESM output
-    zisi_esbuild_require_banner: false,
+    // Output CJS file extension
+    zisi_output_cjs_extension: false,
 };
 // List of supported flags and their default value.
 export const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/manifest.d.ts

@@ -5,6 +5,9 @@ interface ManifestFunction {
     path: string;
     runtime: string;
     schedule?: string;
+    displayName?: string;
+    bundler?: string;
+    isInternal?: boolean;
 }
 export interface Manifest {
     functions: ManifestFunction[];

package/dist/manifest.js

@@ -12,11 +12,14 @@ export const createManifest = async ({ functions, path }) => {
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
-const formatFunctionForManifest = ({ mainFile, name, path, runtime, schedule }) => ({
+const formatFunctionForManifest = ({ mainFile, name, path, runtime, schedule, displayName, bundler, isInternal, }) => ({
     mainFile,
     name,
     path: resolve(path),
     runtime,
     schedule,
+    displayName,
+    bundler,
+    isInternal,
 });
 //# sourceMappingURL=manifest.js.map

package/dist/runtimes/go/index.js

@@ -66,7 +66,7 @@ const processSource = async ({ cache, mainFile, path, }) => {
         stat,
     };
 };
-const zipFunction = async function ({ config, destFolder, filename, mainFile, srcDir, srcPath, stat }) {
+const zipFunction = async function ({ config, destFolder, filename, mainFile, srcDir, srcPath, stat, isInternal, }) {
     const destPath = join(destFolder, filename);
     const isSource = extname(mainFile) === '.go';
     let binary = {
@@ -100,7 +100,12 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
     if (!isSource) {
         await copyFile(binary.path, destPath);
     }
-    return { config, path: destPath };
+    return {
+        config,
+        path: destPath,
+        displayName: config?.name,
+        isInternal,
+    };
 };
 const runtime = { findFunctionsInPaths, findFunctionInPath, name: "go" /* RuntimeType.GO */, zipFunction };
 export default runtime;

package/dist/runtimes/node/bundlers/esbuild/bundler.d.ts

@@ -1,6 +1,6 @@
 import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
-import { ModuleFileExtension, ModuleFormat } from '../../utils/module_format.js';
+import { ModuleFormat } from '../../utils/module_format.js';
 export declare const ESBUILD_LOG_LIMIT = 10;
 export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, featureFlags, ignoredModules, mainFile, name, srcDir, srcFile, }: {
     additionalModulePaths?: string[] | undefined;
@@ -17,10 +17,10 @@ export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, e
     additionalPaths: string[];
     bundlePaths: Map<string, string>;
     cleanTempFiles: () => Promise<void>;
-    extension: ModuleFileExtension;
     inputs: string[];
     moduleFormat: ModuleFormat;
     nativeNodeModules: {};
     nodeModulesWithDynamicImports: string[];
+    outputExtension: import("../../utils/module_format.js").ModuleFileExtension;
     warnings: import("@netlify/esbuild").Message[];
 }>;

package/dist/runtimes/node/bundlers/esbuild/bundler.js

@@ -56,9 +56,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
     // to a `package.json` with {"type": "module"} in case of an ESM function.
     const { includedFiles: includedFilesFromModuleDetection, moduleFormat } = await getModuleFormat(srcDir, featureFlags, extname(mainFile), config.nodeVersion);
     // The extension of the output file.
-    const extension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    // When outputting an ESM file, configure esbuild to produce a `.mjs` file.
-    const outExtension = moduleFormat === "esm" /* ModuleFormat.ESM */ ? { [".js" /* ModuleFileExtension.JS */]: ".mjs" /* ModuleFileExtension.MJS */ } : undefined;
+    const outputExtension = getFileExtensionForFormat(moduleFormat, featureFlags);
     // We add this banner so that calls to require() still work in ESM modules, especially when importing node built-ins
     // We have to do this until this is fixed in esbuild: https://github.com/evanw/esbuild/pull/2067
     const esmJSBanner = `
@@ -71,7 +69,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
   `;
     try {
         const { metafile = { inputs: {}, outputs: {} }, warnings } = await build({
-            banner: moduleFormat === "esm" /* ModuleFormat.ESM */ && featureFlags.zisi_esbuild_require_banner ? { js: esmJSBanner } : undefined,
+            banner: moduleFormat === "esm" /* ModuleFormat.ESM */ ? { js: esmJSBanner } : undefined,
             bundle: true,
             entryPoints: [srcFile],
             external,
@@ -80,8 +78,8 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
             logLimit: ESBUILD_LOG_LIMIT,
             metafile: true,
             nodePaths: additionalModulePaths,
-            outExtension,
             outdir: targetDirectory,
+            outExtension: { '.js': outputExtension },
             platform: 'node',
             plugins,
             resolveExtensions: RESOLVE_EXTENSIONS,
@@ -91,9 +89,9 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
         });
         const bundlePaths = getBundlePaths({
             destFolder: targetDirectory,
-            extension,
             outputs: metafile.outputs,
             srcFile,
+            outputExtension,
         });
         const inputs = Object.keys(metafile.inputs).map((path) => resolve(path));
         const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()]);
@@ -102,11 +100,11 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
             additionalPaths,
             bundlePaths,
             cleanTempFiles,
-            extension,
             inputs,
             moduleFormat,
             nativeNodeModules,
             nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
+            outputExtension,
             warnings,
         };
     }
@@ -122,7 +120,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
 // absolute paths of the generated files as keys, and the paths that those
 // files should take in the generated bundle as values. This is compatible
 // with the `aliases` format used upstream.
-const getBundlePaths = ({ destFolder, extension: outputExtension, outputs, srcFile, }) => {
+const getBundlePaths = ({ destFolder, outputExtension, outputs, srcFile, }) => {
     const bundleFilename = basename(srcFile, extname(srcFile)) + outputExtension;
     const mainFileDirectory = dirname(srcFile);
     const bundlePaths = new Map();

package/dist/runtimes/node/bundlers/esbuild/bundler_target.d.ts

@@ -9,7 +9,7 @@ declare const versionMap: {
     readonly '16.x': "node16";
     readonly '18.x': "node18";
 };
-type VersionValues = typeof versionMap[keyof typeof versionMap];
+type VersionValues = (typeof versionMap)[keyof typeof versionMap];
 declare const getBundlerTarget: (suppliedVersion?: NodeVersionString) => VersionValues;
 declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, extension: string, configVersion?: string) => Promise<{
     includedFiles: string[];

package/dist/runtimes/node/bundlers/esbuild/index.js

@@ -28,7 +28,7 @@ const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
 };
 const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => {
     const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, extension: outputExtension, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await bundleJsFile({
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, outputExtension, warnings, } = await bundleJsFile({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
         basePath,
         config,

package/dist/runtimes/node/bundlers/nft/index.js

@@ -43,9 +43,9 @@ const ignoreFunction = (path) => {
 const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, }) {
     const { fileList: dependencyPaths, esmFileList, reasons, } = await nodeFileTrace([mainFile], {
         // Default is 1024. Allowing double the fileIO in parallel makes nft faster, but uses a little more memory.
-        fileIOConcurrency: featureFlags.zisi_nft_higher_fileio_limit ? 2048 : 1024,
+        fileIOConcurrency: 2048,
         base: basePath,
-        cache: featureFlags.zisi_nft_use_cache ? cache.nftCache : undefined,
+        cache: cache.nftCache,
         ignore: ignoreFunction,
         readFile: async (path) => {
             try {

package/dist/runtimes/node/index.js

@@ -19,7 +19,7 @@ const getSrcFilesWithBundler = async (parameters) => {
     const result = await bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
     return result.srcFiles;
 };
-const zipFunction = async function ({ archiveFormat, basePath, cache, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
+const zipFunction = async function ({ archiveFormat, basePath, cache, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, isInternal, }) {
     const pluginsModulesPath = await getPluginsModulesPath(srcDir);
     const bundlerName = await getBundlerName({
         config,
@@ -78,6 +78,8 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         nativeNodeModules,
         nodeModulesWithDynamicImports,
         path: zipPath,
+        displayName: config?.name,
+        isInternal,
     };
 };
 const zipWithFunctionWithFallback = async ({ config = {}, ...parameters }) => {

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

@@ -1,7 +1,23 @@
+import type { FeatureFlags } from '../../../feature_flags.js';
 import { ModuleFormat } from './module_format.js';
-export declare const getEntryFile: ({ commonPrefix, mainFile, moduleFormat, userNamespace, }: {
+export interface EntryFile {
+    contents: string;
+    filename: string;
+}
+export declare const isNamedLikeEntryFile: (file: string, { basePath, filename, }: {
+    basePath: string;
+    filename: string;
+}) => boolean;
+export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, mainFile, filename, }: {
+    basePath: string;
+    filename: string;
+    mainFile: string;
+}) => boolean;
+export declare const getEntryFile: ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, }: {
     commonPrefix: string;
+    featureFlags: FeatureFlags;
+    filename: string;
     mainFile: string;
     moduleFormat: ModuleFormat;
     userNamespace: string;
-}) => string;
+}) => EntryFile;

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

@@ -1,10 +1,35 @@
+import { basename, extname, resolve } from 'path';
+import { getFileExtensionForFormat } from './module_format.js';
 import { normalizeFilePath } from './normalize_path.js';
-export const getEntryFile = ({ commonPrefix, mainFile, moduleFormat, userNamespace, }) => {
-    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
+const getEntryFileContents = (mainPath, moduleFormat) => {
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
     if (moduleFormat === "cjs" /* ModuleFormat.COMMONJS */) {
         return `module.exports = require('${importPath}')`;
     }
     return `export { handler } from '${importPath}'`;
 };
+// They are in the order that AWS Lambda will try to find the entry point
+const POSSIBLE_LAMBDA_ENTRY_EXTENSIONS = [".js" /* ModuleFileExtension.JS */, ".mjs" /* ModuleFileExtension.MJS */, ".cjs" /* ModuleFileExtension.CJS */];
+// checks if the file is considered a entry-file in AWS Lambda
+export const isNamedLikeEntryFile = (file, { basePath, filename, }) => POSSIBLE_LAMBDA_ENTRY_EXTENSIONS.some((extension) => {
+    const entryFilename = getEntryFileName({ extension, filename });
+    const entryFilePath = resolve(basePath, entryFilename);
+    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);
+// 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
+const getEntryFileName = ({ extension, filename }) => `${basename(filename, extname(filename))}${extension}`;
+export const getEntryFile = ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, }) => {
+    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
+    const extension = getFileExtensionForFormat(moduleFormat, featureFlags);
+    const entryFilename = getEntryFileName({ extension, filename });
+    const contents = getEntryFileContents(mainPath, moduleFormat);
+    return {
+        contents,
+        filename: entryFilename,
+    };
+};
 //# sourceMappingURL=entry_file.js.map

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

@@ -2,6 +2,9 @@ export const getFileExtensionForFormat = (moduleFormat, featureFlags) => {
     if (moduleFormat === "esm" /* ModuleFormat.ESM */ && featureFlags.zisi_pure_esm_mjs) {
         return ".mjs" /* ModuleFileExtension.MJS */;
     }
+    if (featureFlags.zisi_output_cjs_extension && moduleFormat === "cjs" /* ModuleFormat.COMMONJS */) {
+        return ".cjs" /* ModuleFileExtension.CJS */;
+    }
     return ".js" /* ModuleFileExtension.JS */;
 };
 //# sourceMappingURL=module_format.js.map

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

@@ -1,14 +1,13 @@
 import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
 import os from 'os';
-import { basename, join, resolve } from 'path';
+import { basename, join } from 'path';
 import { copyFile } from 'cp-file';
 import { deleteAsync as deleteFiles } from 'del';
 import pMap from 'p-map';
 import { startZip, addZipFile, addZipContent, endZip } from '../../../archive.js';
 import { cachedLstat, mkdirAndWriteFile } from '../../../utils/fs.js';
-import { getEntryFile } from './entry_file.js';
-import { getFileExtensionForFormat } from './module_format.js';
+import { conflictsWithEntryFile, getEntryFile, isNamedLikeEntryFile } from './entry_file.js';
 import { normalizeFilePath } from './normalize_path.js';
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
@@ -16,21 +15,20 @@ const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
 // the entry file generated by zip-it-and-ship-it).
 const DEFAULT_USER_SUBDIRECTORY = 'src';
 const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites = new Map(), srcFiles, }) {
-    const entryFile = getEntryFile({
+    const { contents: entryContents, filename: entryFilename } = getEntryFile({
         commonPrefix: basePath,
+        featureFlags,
+        filename,
         mainFile,
         moduleFormat,
         userNamespace: DEFAULT_USER_SUBDIRECTORY,
     });
-    const entryFileExtension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    const entryFilename = basename(filename, extension) + entryFileExtension;
     const functionFolder = join(destFolder, basename(filename, extension));
-    const entryFilePath = resolve(functionFolder, entryFilename);
     // Deleting the functions directory in case it exists before creating it.
     await deleteFiles(functionFolder, { force: true });
     await fs.mkdir(functionFolder, { recursive: true });
     // Writing entry file.
-    await fs.writeFile(entryFilePath, entryFile);
+    await fs.writeFile(join(functionFolder, entryFilename), entryContents);
     // Copying source files.
     await pMap(srcFiles, (srcFile) => {
         const destPath = aliases.get(srcFile) || srcFile;
@@ -50,22 +48,30 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
 const createZipArchive = async function ({ aliases, basePath, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
     const destPath = join(destFolder, `${basename(filename, extension)}.zip`);
     const { archive, output } = startZip(destPath);
-    const entryFileExtension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    const entryFilename = basename(filename, extension) + entryFileExtension;
-    const entryFilePath = resolve(basePath, entryFilename);
-    // We don't need an entry file if it would end up with the same path as the
-    // function's main file.
-    const needsEntryFile = entryFilePath !== mainFile;
     // There is a naming conflict with the entry file if one of the supporting
     // files (i.e. not the main file) has the path that the entry file needs to
     // take.
-    const hasEntryFileConflict = srcFiles.some((srcFile) => srcFile === entryFilePath && srcFile !== mainFile);
+    const hasEntryFileConflict = conflictsWithEntryFile(srcFiles, {
+        basePath,
+        filename,
+        mainFile,
+    });
+    // We don't need an entry file if it would end up with the same path as the
+    // function's main file. Unless we have a file conflict and need to move everything into a subfolder
+    const needsEntryFile = hasEntryFileConflict || !isNamedLikeEntryFile(mainFile, { basePath, filename });
     // If there is a naming conflict, we move all user files (everything other
     // than the entry file) to its own sub-directory.
     const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : '';
     if (needsEntryFile) {
-        const entryFile = getEntryFile({ commonPrefix: basePath, mainFile, moduleFormat, userNamespace });
-        addEntryFileToZip(archive, entryFile, basename(entryFilePath));
+        const entryFile = getEntryFile({
+            commonPrefix: basePath,
+            filename,
+            mainFile,
+            moduleFormat,
+            userNamespace,
+            featureFlags,
+        });
+        addEntryFileToZip(archive, entryFile);
     }
     const srcFilesInfos = await Promise.all(srcFiles.map((file) => addStat(cache, file)));
     // We ensure this is not async, so that the archive's checksum is
@@ -90,7 +96,7 @@ export const zipNodeJs = function ({ archiveFormat, ...options }) {
     }
     return createDirectory(options);
 };
-const addEntryFileToZip = function (archive, contents, filename) {
+const addEntryFileToZip = function (archive, { contents, filename }) {
     const contentBuffer = Buffer.from(contents);
     addZipContent(archive, contentBuffer, filename);
 };

package/dist/runtimes/runtime.d.ts

@@ -37,6 +37,8 @@ export interface ZipFunctionResult {
     nativeNodeModules?: object;
     nodeModulesWithDynamicImports?: string[];
     path: string;
+    isInternal?: boolean;
+    displayName?: string;
 }
 export type ZipFunction = (args: {
     archiveFormat: ArchiveFormat;
@@ -46,6 +48,7 @@ export type ZipFunction = (args: {
     destFolder: string;
     featureFlags: FeatureFlags;
     repositoryRoot?: string;
+    isInternal?: boolean;
 } & FunctionSource) => Promise<ZipFunctionResult>;
 export interface Runtime {
     findFunctionsInPaths: FindFunctionsInPathsFunction;

package/dist/runtimes/rust/index.js

@@ -80,7 +80,7 @@ const processSource = async ({ cache, mainFile, path, }) => {
 // The name of the binary inside the zip file must always be `bootstrap`
 // because they include the Lambda runtime, and that's the name that AWS
 // expects for those kind of functions.
-const zipFunction = async function ({ cache, config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat, }) {
+const zipFunction = async function ({ cache, config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat, isInternal, }) {
     const destPath = join(destFolder, `${filename}.zip`);
     const isSource = extname(mainFile) === '.rs';
     const zipOptions = {
@@ -98,7 +98,12 @@ const zipFunction = async function ({ cache, config, destFolder, filename, mainF
     else {
         await zipBinary({ ...zipOptions, srcPath, stat });
     }
-    return { config, path: destPath };
+    return {
+        config,
+        path: destPath,
+        displayName: config?.name,
+        isInternal,
+    };
 };
 const runtime = { findFunctionsInPaths, findFunctionInPath, name: "rs" /* RuntimeType.RUST */, zipFunction };
 export default runtime;

package/dist/zip.d.ts

@@ -11,15 +11,17 @@ interface ZipFunctionOptions {
     zipGo?: boolean;
     systemLog?: LogFunction;
     debug?: boolean;
+    internalSrcFolder?: string;
 }
 export type ZipFunctionsOptions = ZipFunctionOptions & {
     configFileDirectories?: string[];
     manifest?: string;
     parallelLimit?: number;
+    internalSrcFolder?: string;
 };
-export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
+export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
     runtime: import("./main.js").RuntimeType;
     schedule?: string | undefined;
 })[]>;
-export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, systemLog, debug, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
+export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
 export {};

package/dist/zip.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'fs';
 import { resolve } from 'path';
+import isPathInside from 'is-path-inside';
 import pMap from 'p-map';
 import { getFlags } from './feature_flags.js';
 import { createManifest } from './manifest.js';
@@ -20,12 +21,13 @@ const validateArchiveFormat = (archiveFormat) => {
 };
 // Zip `srcFolder/*` (Node.js or Go files) to `destFolder/*.zip` so it can be
 // used by AWS Lambda
-export const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFormat = 'zip', basePath, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, } = {}) {
+export const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFormat = 'zip', basePath, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, internalSrcFolder, } = {}) {
     validateArchiveFormat(archiveFormat);
     const logger = getLogger(systemLog, debug);
     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,
@@ -58,6 +60,7 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
             srcDir: func.srcDir,
             srcPath: func.srcPath,
             stat: func.stat,
+            isInternal: Boolean(internalFunctionsPath && isPathInside(func.srcPath, internalFunctionsPath)),
         });
         const durationNs = endTimer(startIntervalTime);
         const logObject = {
@@ -81,13 +84,14 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
     return formattedResults;
 };
 // eslint-disable-next-line max-statements
-export const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, systemLog, debug, } = {}) {
+export const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, systemLog, debug, internalSrcFolder, } = {}) {
     validateArchiveFormat(archiveFormat);
     const logger = getLogger(systemLog, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     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;
     }
@@ -116,6 +120,7 @@ export const zipFunction = async function (relativeSrcPath, destFolder, { archiv
         srcDir,
         srcPath,
         stat: stats,
+        isInternal: Boolean(internalFunctionsPath && isPathInside(srcPath, internalFunctionsPath)),
     });
     const durationNs = endTimer(startIntervalTime);
     const logObject = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "8.2.0",
+  "version": "8.4.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -16,6 +16,7 @@
     "prepublishOnly": "npm ci && npm test",
     "prepack": "npm run build",
     "build": "tsc",
+    "build:dev": "tsc -w",
     "benchmark": "./benchmarks/run.sh",
     "format": "run-s build format:check-fix:*",
     "format:ci": "run-s build format:check:*",
@@ -97,7 +98,7 @@
     "@types/tmp": "^0.2.3",
     "@types/unixify": "^1.0.0",
     "@types/yargs": "^17.0.4",
-    "@vitest/coverage-c8": "^0.25.0",
+    "@vitest/coverage-c8": "^0.27.0",
     "cpy": "^9.0.0",
     "deepmerge": "^4.2.2",
     "get-stream": "^6.0.0",
@@ -108,7 +109,7 @@
     "throat": "^6.0.1",
     "typescript": "^4.8.4",
     "vite": "^4.0.0",
-    "vitest": "^0.25.0"
+    "vitest": "^0.27.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"