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

package/README.md

@@ -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

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

@@ -66,11 +66,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/package.json

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