@netlify/zip-it-and-ship-it 12.2.1 → 13.0.0

package/dist/main.d.ts

@@ -4,7 +4,7 @@ import { ModuleFormat } from './runtimes/node/utils/module_format.js';
 import { RuntimeName } from './runtimes/runtime.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 export { Config, FunctionConfig } from './config.js';
-export { zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
+export { type FunctionsBag, zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
 export { ArchiveFormat, ARCHIVE_FORMAT } from './archive.js';
 export type { TrafficRules } from './rate_limit.js';
 export type { ExtendedRoute, Route } from './utils/routes.js';

package/dist/utils/fs.js

@@ -65,24 +65,8 @@ ${errorMessages.join('\n')}`);
     return validDirectories.flat();
 };
 const listFunctionsDirectory = async function (srcPath) {
-    try {
-        const filenames = await fs.readdir(srcPath);
-        return filenames.map((name) => join(srcPath, name));
-    }
-    catch (error) {
-        // We could move the `stat` call up and use its result to decide whether to
-        // treat the path as a file or as a directory. We're doing it this way since
-        // historically this method only supported directories, and only later we
-        // made it accept files. To roll out that change as safely as possible, we
-        // keep the directory flow untouched and look for files only as a fallback.
-        if (error.code === 'ENOTDIR') {
-            const stat = await fs.stat(srcPath);
-            if (stat.isFile()) {
-                return srcPath;
-            }
-        }
-        throw error;
-    }
+    const filenames = await fs.readdir(srcPath);
+    return filenames.map((name) => join(srcPath, name));
 };
 export const resolveFunctionsDirectories = (input) => {
     const directories = Array.isArray(input) ? input : [input];

package/dist/zip.d.ts

@@ -19,7 +19,41 @@ export type ZipFunctionsOptions = ZipFunctionOptions & {
     configFileDirectories?: string[];
     manifest?: string;
     parallelLimit?: number;
-    internalSrcFolder?: string;
 };
-export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
+export interface FunctionsBag {
+    generated: FunctionsCategory;
+    user: FunctionsCategory;
+}
+export interface FunctionsCategory {
+    /**
+     * List of paths for directories containing one or more functions. Entries in
+     * these directories are considered functions when they are files that match
+     * one of the supported extensions or when they are sub-directories that
+     * contain a function following the sub-directory naming patterns.
+     * Paths can be relative.
+     */
+    directories: string[];
+    /**
+     * List of paths for specific functions. Paths can be files that match one
+     * of the supported extensions or sub-directories that contain a function
+     * following the sub-directory naming patterns. Paths can be relative.
+     */
+    functions: string[];
+}
+/**
+ * Normalizes the `zipFunctions` input into a `FunctionsBag` object.
+ */
+export declare const getFunctionsBag: (input: ZipFunctionsPaths) => FunctionsBag;
+export type ZipFunctionsPaths = string | string[] | {
+    /**
+     * Functions generated on behalf of the user by a build plugin, extension
+     * or a framework.
+     */
+    generated?: Partial<FunctionsCategory>;
+    /**
+     * Functions authored by the user.
+     */
+    user?: Partial<FunctionsCategory>;
+};
+export declare const zipFunctions: (input: ZipFunctionsPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
 export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionOptions) => Promise<FunctionResult | undefined>;

package/dist/zip.js

@@ -19,17 +19,56 @@ const validateArchiveFormat = (archiveFormat) => {
         throw new Error(`Invalid archive format: ${archiveFormat}`);
     }
 };
+/**
+ * Normalizes the `zipFunctions` input into a `FunctionsBag` object.
+ */
+export const getFunctionsBag = (input) => {
+    if (typeof input === 'string') {
+        return {
+            generated: {
+                directories: [],
+                functions: [],
+            },
+            user: {
+                directories: [input],
+                functions: [],
+            },
+        };
+    }
+    if (Array.isArray(input)) {
+        return {
+            generated: {
+                directories: [],
+                functions: [],
+            },
+            user: {
+                directories: input,
+                functions: [],
+            },
+        };
+    }
+    return {
+        generated: {
+            directories: input.generated?.directories ?? [],
+            functions: input.generated?.functions ?? [],
+        },
+        user: {
+            directories: input.user?.directories ?? [],
+            functions: input.user?.functions ?? [],
+        },
+    };
+};
 // 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 = ARCHIVE_FORMAT.ZIP, basePath, branch, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, internalSrcFolder, } = {}) {
+export const zipFunctions = async function (input, destFolder, { archiveFormat = ARCHIVE_FORMAT.ZIP, basePath, branch, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, } = {}) {
     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 bag = getFunctionsBag(input);
+    const srcFolders = resolveFunctionsDirectories([...bag.generated.directories, ...bag.user.directories]);
     const [paths] = await Promise.all([listFunctionsDirectories(srcFolders), fs.mkdir(destFolder, { recursive: true })]);
-    const functions = await getFunctionsFromPaths(paths, {
+    const functions = await getFunctionsFromPaths([...paths, ...bag.generated.functions, ...bag.user.functions], {
         cache,
         config,
         configFileDirectories,
@@ -43,6 +82,8 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
             // extend the feature flags with `zisi_pure_esm_mjs` enabled.
             ...(func.config.nodeModuleFormat === MODULE_FORMAT.ESM ? { zisi_pure_esm_mjs: true } : {}),
         };
+        const isInternal = bag.generated.functions.includes(func.srcPath) ||
+            bag.generated.directories.some((directory) => isPathInside(func.srcPath, directory));
         const zipResult = await func.runtime.zipFunction({
             archiveFormat,
             basePath,
@@ -53,7 +94,7 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
             extension: func.extension,
             featureFlags: functionFlags,
             filename: func.filename,
-            isInternal: Boolean(internalFunctionsPath && isPathInside(func.srcPath, internalFunctionsPath)),
+            isInternal,
             logger,
             mainFile: func.mainFile,
             name: func.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "12.2.1",
+  "version": "13.0.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "a317a69700be1392b54976ef34b456ac47d75f5a"
+  "gitHead": "cc8bccf13040e0e43282845c5a3a6d17db659ce8"
 }