@netlify/zip-it-and-ship-it 5.0.0 → 5.4.0-isc-listfunctions

package/dist/feature_flags.js

@@ -6,7 +6,6 @@ const FLAGS = {
     buildGoSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
     buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
     defaultEsModulesToEsbuild: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
-    nftTranspile: false,
     parseWithEsbuild: false,
     traceWithNft: false,
 };

package/dist/function.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Stats } from 'fs';
 import type { FunctionConfig } from './config';
+import { ISCValues } from './runtimes/node/in_source_config';
 import type { Runtime, ZipFunctionResult } from './runtimes/runtime';
 declare type FunctionArchive = ZipFunctionResult & {
     mainFile: string;
@@ -16,6 +17,7 @@ interface SourceFile {
     srcDir: string;
     srcPath: string;
     stat: Stats;
+    inSourceConfig?: ISCValues;
 }
 declare type FunctionSource = SourceFile & {
     config: FunctionConfig;

package/dist/main.d.ts

@@ -6,6 +6,7 @@ interface ListedFunction {
     mainFile: string;
     runtime: RuntimeName;
     extension: string;
+    schedule?: string;
 }
 declare type ListedFunctionFile = ListedFunction & {
     srcFile: string;
@@ -15,9 +16,14 @@ interface ListFunctionsOptions {
     config?: Config;
     featureFlags?: FeatureFlags;
 }
-declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags }?: {
-    featureFlags?: FeatureFlags;
+declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config }?: {
+    featureFlags?: FeatureFlags | undefined;
+    config?: Config | undefined;
 }) => Promise<ListedFunction[]>;
+declare const listFunction: (mainFile: string, { featureFlags: inputFeatureFlags, config }?: {
+    featureFlags?: FeatureFlags | undefined;
+    config?: Config | undefined;
+}) => Promise<ListedFunction | undefined>;
 declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
-export { listFunctions, listFunctionsFiles };
+export { listFunctions, listFunction, listFunctionsFiles };
 export { zipFunction, zipFunctions } from './zip';

package/dist/main.js

@@ -20,23 +20,35 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunctions = void 0;
+exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = void 0;
 const path_1 = require("path");
 const feature_flags_1 = require("./feature_flags");
 const runtimes_1 = require("./runtimes");
 const fs_1 = require("./utils/fs");
 // List all Netlify Functions main entry files for a specific directory
-const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags } = {}) {
+const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
         const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
         const paths = yield (0, fs_1.listFunctionsDirectories)(srcFolders);
-        const functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags });
+        const functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags, config });
         const listedFunctions = [...functions.values()].map(getListedFunction);
         return listedFunctions;
     });
 };
 exports.listFunctions = listFunctions;
+// List one Netlify Functions main entry file for a specific directory
+const listFunction = function (mainFile, { featureFlags: inputFeatureFlags, config } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
+        const func = yield (0, runtimes_1.getFunctionFromPath)(mainFile, { featureFlags, config });
+        if (!func) {
+            return;
+        }
+        return getListedFunction(func);
+    });
+};
+exports.listFunction = listFunction;
 // List all Netlify Functions files for a specific directory
 const listFunctionsFiles = function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -49,14 +61,14 @@ const listFunctionsFiles = function (relativeSrcFolders, { basePath, config, fea
     });
 };
 exports.listFunctionsFiles = listFunctionsFiles;
-const getListedFunction = function ({ runtime, name, mainFile, extension }) {
-    return { name, mainFile, runtime: runtime.name, extension };
+const getListedFunction = function ({ runtime, name, mainFile, extension, config, inSourceConfig, }) {
+    var _a;
+    return { name, mainFile, runtime: runtime.name, extension, schedule: (_a = inSourceConfig === null || inSourceConfig === void 0 ? void 0 : inSourceConfig.schedule) !== null && _a !== void 0 ? _a : config.schedule };
 };
 const getListedFunctionFiles = function (func, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const srcFiles = yield getSrcFiles(Object.assign(Object.assign({}, func), options));
-        const { name, mainFile, runtime } = func;
-        return srcFiles.map((srcFile) => ({ srcFile, name, mainFile, runtime: runtime.name, extension: (0, path_1.extname)(srcFile) }));
+        return srcFiles.map((srcFile) => (Object.assign(Object.assign({}, getListedFunction(func)), { srcFile, extension: (0, path_1.extname)(srcFile) })));
     });
 };
 const getSrcFiles = function (_a) {

package/dist/runtimes/go/index.js

@@ -35,22 +35,25 @@ const detectGoFunction = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0
 });
 const findFunctionsInPaths = function ({ featureFlags, fsCache, paths }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const functions = yield Promise.all(paths.map((path) => __awaiter(this, void 0, void 0, function* () {
-            const runtime = yield (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
-            if (runtime === 'go') {
-                return processBinary({ fsCache, path });
-            }
-            if (featureFlags.buildGoSource !== true) {
-                return;
-            }
-            const goSourceFile = yield detectGoFunction({ fsCache, path });
-            if (goSourceFile) {
-                return processSource({ fsCache, mainFile: goSourceFile, path });
-            }
-        })));
+        const functions = yield Promise.all(paths.map((path) => getFunctionAtPath(path, { featureFlags, fsCache })));
         return functions.filter(non_nullable_1.nonNullable);
     });
 };
+const getFunctionAtPath = function (path, { featureFlags, fsCache }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const runtime = yield (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+        if (runtime === 'go') {
+            return processBinary({ fsCache, path });
+        }
+        if (featureFlags.buildGoSource !== true) {
+            return;
+        }
+        const goSourceFile = yield detectGoFunction({ fsCache, path });
+        if (goSourceFile) {
+            return processSource({ fsCache, mainFile: goSourceFile, path });
+        }
+    });
+};
 const processBinary = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
     const stat = (yield (0, fs_1.cachedLstat)(fsCache, path));
     const extension = (0, path_1.extname)(path);
@@ -96,6 +99,6 @@ const zipFunction = function ({ config, destFolder, filename, mainFile, srcDir,
         return { config, path: destPath };
     });
 };
-const runtime = { findFunctionsInPaths, name: 'go', zipFunction };
+const runtime = { findFunctionsInPaths, getFunctionAtPath, name: 'go', zipFunction };
 exports.default = runtime;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/index.d.ts

@@ -10,4 +10,11 @@ declare const getFunctionsFromPaths: (paths: string[], { config, dedupe, feature
     dedupe?: boolean | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionMap>;
-export { getFunctionsFromPaths };
+/**
+ * Gets a list of functions found in a list of paths.
+ */
+declare const getFunctionFromPath: (path: string, { config, featureFlags }?: {
+    config?: Config | undefined;
+    featureFlags?: FeatureFlags | undefined;
+}) => Promise<FunctionSource | undefined>;
+export { getFunctionsFromPaths, getFunctionFromPath };

package/dist/runtimes/index.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionsFromPaths = void 0;
+exports.getFunctionFromPath = exports.getFunctionsFromPaths = void 0;
 const path_1 = require("path");
 const config_1 = require("../config");
 const feature_flags_1 = require("../feature_flags");
@@ -42,23 +42,24 @@ const findFunctionsInRuntime = function ({ dedupe = false, featureFlags, fsCache
         return { functions: augmentedFunctions, remainingPaths };
     });
 };
+// An object to cache filesystem operations. This allows different functions
+// to perform IO operations on the same file (i.e. getting its stats or its
+// contents) without duplicating work.
+const makeFsCache = () => ({});
+// The order of this array determines the priority of the runtimes. If a path
+// is used by the first time, it won't be made available to the subsequent
+// runtimes.
+const RUNTIMES = [node_1.default, go_1.default, rust_1.default];
 /**
  * Gets a list of functions found in a list of paths.
  */
 const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags = feature_flags_1.defaultFlags, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    // An object to cache filesystem operations. This allows different functions
-    // to perform IO operations on the same file (i.e. getting its stats or its
-    // contents) without duplicating work.
-    const fsCache = {};
-    // The order of this array determines the priority of the runtimes. If a path
-    // is used by the first time, it won't be made available to the subsequent
-    // runtimes.
-    const runtimes = [node_1.default, go_1.default, rust_1.default];
+    const fsCache = makeFsCache();
     // We cycle through the ordered array of runtimes, passing each one of them
     // through `findFunctionsInRuntime`. For each iteration, we collect all the
     // functions found plus the list of paths that still need to be evaluated,
     // using them as the input for the next iteration until the last runtime.
-    const { functions } = yield runtimes.reduce((aggregate, runtime) => __awaiter(void 0, void 0, void 0, function* () {
+    const { functions } = yield RUNTIMES.reduce((aggregate, runtime) => __awaiter(void 0, void 0, void 0, function* () {
         const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = yield aggregate;
         const { functions: runtimeFunctions, remainingPaths: runtimePaths } = yield findFunctionsInRuntime({
             dedupe,
@@ -79,4 +80,19 @@ const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags = f
     return new Map(functionsWithConfig);
 });
 exports.getFunctionsFromPaths = getFunctionsFromPaths;
+/**
+ * Gets a list of functions found in a list of paths.
+ */
+const getFunctionFromPath = (path, { config, featureFlags = feature_flags_1.defaultFlags } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const fsCache = makeFsCache();
+    for (const runtime of RUNTIMES) {
+        // eslint-disable-next-line no-await-in-loop
+        const func = yield runtime.getFunctionAtPath(path, { fsCache, featureFlags });
+        if (func) {
+            return Object.assign(Object.assign({}, func), { runtime, config: (0, config_1.getConfigForFunction)({ config, func: Object.assign(Object.assign({}, func), { runtime }) }) });
+        }
+    }
+    return undefined;
+});
+exports.getFunctionFromPath = getFunctionFromPath;
 //# sourceMappingURL=index.js.map

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

@@ -24,7 +24,7 @@ const es_modules_1 = require("./es_modules");
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = ({ basePath, config, featureFlags, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => __awaiter(void 0, void 0, void 0, function* () {
+const bundle = ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot = basePath, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { exclude: excludedPaths, paths: includedFilePaths } = yield (0, included_files_1.getPathsOfIncludedFiles)(includedFiles, includedFilesBasePath || basePath);
     const { paths: dependencyPaths, rewrites } = yield traceFilesAndTranspile({
@@ -32,7 +32,6 @@ const bundle = ({ basePath, config, featureFlags, mainFile, pluginsModulesPath,
         config,
         mainFile,
         pluginsModulesPath,
-        transpile: featureFlags.nftTranspile,
     });
     const filteredIncludedPaths = (0, included_files_1.filterExcludedPaths)([...dependencyPaths, ...includedFilePaths], excludedPaths);
     const dirnames = filteredIncludedPaths.map((filePath) => (0, path_1.normalize)((0, path_1.dirname)(filePath))).sort();
@@ -51,7 +50,7 @@ const ignoreFunction = (path) => {
     const shouldIgnore = ignore.some((expression) => (0, minimatch_1.default)(normalizedPath, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsModulesPath, transpile, }) {
+const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsModulesPath, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const fsCache = {};
         const { fileList: dependencyPaths, esmFileList, reasons, } = yield (0, nft_1.nodeFileTrace)([mainFile], {
@@ -86,9 +85,7 @@ const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsMo
             }),
         });
         const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-        const rewrites = transpile
-            ? yield (0, es_modules_1.transpileESM)({ basePath, config, esmPaths: esmFileList, fsCache, reasons })
-            : undefined;
+        const rewrites = yield (0, es_modules_1.transpileESM)({ basePath, config, esmPaths: esmFileList, fsCache, reasons });
         return {
             paths: normalizedDependencyPaths,
             rewrites,

package/dist/runtimes/node/finder.d.ts

@@ -1,6 +1,4 @@
-import { SourceFile } from '../../function';
-declare const findFunctionsInPaths: ({ paths }: {
-    paths: string[];
-}) => Promise<SourceFile[]>;
-declare const getFunctionAtPath: (srcPath: string) => Promise<SourceFile | undefined>;
+import { FindFunctionsInPathsFunction, GetFunctionAtPathFunction } from '../runtime';
+declare const findFunctionsInPaths: FindFunctionsInPathsFunction;
+declare const getFunctionAtPath: GetFunctionAtPathFunction;
 export { findFunctionsInPaths, getFunctionAtPath };

package/dist/runtimes/node/finder.js

@@ -18,6 +18,7 @@ const path_1 = require("path");
 const util_1 = require("util");
 const locate_path_1 = __importDefault(require("locate-path"));
 const non_nullable_1 = require("../../utils/non_nullable");
+const in_source_config_1 = require("./in_source_config");
 const pLstat = (0, util_1.promisify)(fs_1.lstat);
 // List of extensions that this runtime will look for, in order of precedence.
 const allowedExtensions = ['.js', '.zip', '.cjs', '.mjs', '.ts'];
@@ -30,9 +31,9 @@ const sortByExtension = (fA, fB) => {
     const indexB = allowedExtensions.indexOf(fB.extension);
     return indexB - indexA;
 };
-const findFunctionsInPaths = function ({ paths }) {
+const findFunctionsInPaths = function ({ paths, fsCache, featureFlags }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const functions = yield Promise.all(paths.map(getFunctionAtPath));
+        const functions = yield Promise.all(paths.map((path) => getFunctionAtPath(path, { fsCache, featureFlags })));
         // It's fine to mutate the array since its scope is local to this function.
         const sortedFunctions = functions.filter(non_nullable_1.nonNullable).sort((fA, fB) => {
             // We first sort the functions array to put directories first. This is so
@@ -63,10 +64,11 @@ const getFunctionAtPath = function (srcPath) {
         if (mainFile === undefined) {
             return;
         }
+        const iscValues = yield (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
         const extension = (0, path_1.extname)(srcPath);
         const srcDir = stat.isDirectory() ? srcPath : (0, path_1.dirname)(srcPath);
         const name = (0, path_1.basename)(srcPath, (0, path_1.extname)(srcPath));
-        return { extension, filename, mainFile, name, srcDir, srcPath, stat };
+        return { extension, filename, mainFile, name, srcDir, srcPath, stat, inSourceConfig: iscValues };
     });
 };
 exports.getFunctionAtPath = getFunctionAtPath;

package/dist/runtimes/node/in_source_config/index.d.ts

@@ -0,0 +1,12 @@
+import { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName } from '@babel/types';
+import { parse as parseSchedule } from './properties/schedule';
+declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
+declare type ISCValues = Partial<ReturnType<typeof parseSchedule>>;
+declare const findISCDeclarationsInPath: (sourcePath: string) => Promise<ISCValues>;
+declare type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
+interface ISCExport {
+    local: string;
+    args: ISCHandlerArg[];
+}
+export { findISCDeclarationsInPath, IN_SOURCE_CONFIG_MODULE };
+export type { ISCExport, ISCHandlerArg, ISCValues };

package/dist/runtimes/node/in_source_config/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IN_SOURCE_CONFIG_MODULE = exports.findISCDeclarationsInPath = void 0;
+const non_nullable_1 = require("../../../utils/non_nullable");
+const parser_1 = require("../parser");
+const exports_1 = require("../parser/exports");
+const imports_1 = require("../parser/imports");
+const schedule_1 = require("./properties/schedule");
+const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
+exports.IN_SOURCE_CONFIG_MODULE = IN_SOURCE_CONFIG_MODULE;
+// Parses a JS/TS file and looks for in-source config declarations. It returns
+// an array of all declarations found, with `property` indicating the name of
+// the property and `data` its value.
+const findISCDeclarationsInPath = (sourcePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const ast = yield (0, parser_1.safelyParseFile)(sourcePath);
+    if (ast === null) {
+        return {};
+    }
+    const imports = ast.body.map((node) => (0, imports_1.getImports)(node, IN_SOURCE_CONFIG_MODULE)).flat();
+    const exports = (0, exports_1.getMainExport)(ast.body);
+    const iscExports = exports
+        .map(({ args, local: exportName }) => {
+        const matchingImport = imports.find(({ local: importName }) => importName === exportName);
+        if (matchingImport === undefined) {
+            return null;
+        }
+        switch (matchingImport.imported) {
+            case 'schedule':
+                return (0, schedule_1.parse)({ args });
+            default:
+            // no-op
+        }
+        return null;
+    })
+        .filter(non_nullable_1.nonNullable);
+    const mergedExports = iscExports.reduce((acc, obj) => (Object.assign(Object.assign({}, acc), obj)), {});
+    return mergedExports;
+});
+exports.findISCDeclarationsInPath = findISCDeclarationsInPath;
+//# sourceMappingURL=index.js.map

package/dist/runtimes/node/in_source_config/properties/schedule.d.ts

@@ -0,0 +1,6 @@
+import type { ISCHandlerArg } from '..';
+export declare const parse: ({ args }: {
+    args: ISCHandlerArg[];
+}) => {
+    schedule: string | undefined;
+};

package/dist/runtimes/node/in_source_config/properties/schedule.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const parse = ({ args }) => {
+    const [expression] = args;
+    const schedule = expression.type === 'StringLiteral' ? expression.value : undefined;
+    return {
+        schedule,
+    };
+};
+exports.parse = parse;
+//# sourceMappingURL=schedule.js.map

package/dist/runtimes/node/index.js

@@ -27,6 +27,7 @@ const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
 const bundlers_1 = require("./bundlers");
 const finder_1 = require("./finder");
+const in_source_config_1 = require("./in_source_config");
 const detect_es_module_1 = require("./utils/detect_es_module");
 const plugin_modules_path_1 = require("./utils/plugin_modules_path");
 const zip_1 = require("./utils/zip");
@@ -88,6 +89,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             srcPath,
             stat,
         });
+        const inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
         (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
         const zipPath = yield (0, zip_1.zipNodeJs)({
             aliases,
@@ -106,6 +108,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             bundlerWarnings,
             config,
             inputs,
+            inSourceConfig,
             nativeNodeModules,
             nodeModulesWithDynamicImports,
             path: zipPath,
@@ -135,6 +138,7 @@ const zipWithFunctionWithFallback = (_a) => __awaiter(void 0, void 0, void 0, fu
 });
 const runtime = {
     findFunctionsInPaths: finder_1.findFunctionsInPaths,
+    getFunctionAtPath: finder_1.getFunctionAtPath,
     getSrcFiles: getSrcFilesWithBundler,
     name: 'js',
     zipFunction: zipWithFunctionWithFallback,

package/dist/runtimes/node/parser/exports.d.ts

@@ -0,0 +1,4 @@
+import { Statement } from '@babel/types';
+import type { ISCExport } from '../in_source_config';
+declare const getMainExport: (nodes: Statement[]) => ISCExport[];
+export { getMainExport };

package/dist/runtimes/node/parser/exports.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMainExport = void 0;
+const helpers_1 = require("./helpers");
+// Finds the main handler export in an AST.
+const getMainExport = (nodes) => {
+    let handlerExport = [];
+    nodes.find((node) => {
+        const esmExports = getMainExportFromESM(node);
+        if (esmExports.length !== 0) {
+            handlerExport = esmExports;
+            return true;
+        }
+        const cjsExports = getMainExportFromCJS(node);
+        if (cjsExports.length !== 0) {
+            handlerExport = cjsExports;
+            return true;
+        }
+        return false;
+    });
+    return handlerExport;
+};
+exports.getMainExport = getMainExport;
+// Finds the main handler export in a CJS AST.
+const getMainExportFromCJS = (node) => {
+    const handlerPaths = [
+        ['module', 'exports', 'handler'],
+        ['exports', 'handler'],
+    ];
+    return handlerPaths.flatMap((handlerPath) => {
+        if (!(0, helpers_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+            return [];
+        }
+        return getExportsFromCallExpression(node.expression.right);
+    });
+};
+// Finds the main handler export in an ESM AST.
+// eslint-disable-next-line complexity
+const getMainExportFromESM = (node) => {
+    var _a;
+    if (node.type !== 'ExportNamedDeclaration' || node.exportKind !== 'value') {
+        return [];
+    }
+    const { declaration } = node;
+    if (!declaration || declaration.type !== 'VariableDeclaration') {
+        return [];
+    }
+    const handlerDeclaration = declaration.declarations.find((childDeclaration) => {
+        const { id, type } = childDeclaration;
+        return type === 'VariableDeclarator' && id.type === 'Identifier' && id.name === 'handler';
+    });
+    if (((_a = handlerDeclaration === null || handlerDeclaration === void 0 ? void 0 : handlerDeclaration.init) === null || _a === void 0 ? void 0 : _a.type) !== 'CallExpression') {
+        return [];
+    }
+    const exports = getExportsFromCallExpression(handlerDeclaration.init);
+    return exports;
+};
+const getExportsFromCallExpression = (node) => {
+    const { arguments: args, callee } = node;
+    if (callee.type !== 'Identifier') {
+        return [];
+    }
+    const exports = [{ local: callee.name, args }];
+    return exports;
+};
+//# sourceMappingURL=exports.js.map

package/dist/runtimes/node/parser/helpers.d.ts

@@ -0,0 +1,7 @@
+import { AssignmentExpression, Expression, ExpressionStatement, ImportDeclaration, Statement } from '@babel/types';
+declare const isImport: (node: Statement, importPath: string) => node is ImportDeclaration;
+declare const isModuleExports: (node: Statement, dotExpression?: string[]) => node is ExpressionStatement & {
+    expression: AssignmentExpression;
+};
+declare const isRequire: (node: Expression | undefined | null, requirePath: string) => boolean;
+export { isImport, isModuleExports, isRequire };

package/dist/runtimes/node/parser/helpers.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequire = exports.isModuleExports = exports.isImport = void 0;
+// eslint-disable-next-line complexity
+const isDotExpression = (node, expression) => {
+    if (node.type !== 'MemberExpression') {
+        return false;
+    }
+    const object = expression.slice(0, -1);
+    const [property] = expression.slice(-1);
+    if (node.property.type !== 'Identifier' || node.property.name !== property) {
+        return false;
+    }
+    if (object.length > 1) {
+        return isDotExpression(node.object, object);
+    }
+    return node.object.type === 'Identifier' && object[0] === node.object.name && property === node.property.name;
+};
+const isImport = (node, importPath) => node.type === 'ImportDeclaration' && node.source.value === importPath;
+exports.isImport = isImport;
+const isModuleExports = (node, dotExpression = ['module', 'exports']) => node.type === 'ExpressionStatement' &&
+    node.expression.type === 'AssignmentExpression' &&
+    node.expression.left.type === 'MemberExpression' &&
+    isDotExpression(node.expression.left, dotExpression);
+exports.isModuleExports = isModuleExports;
+const isRequire = (node, requirePath) => {
+    var _a;
+    if (!node || node.type !== 'CallExpression') {
+        return false;
+    }
+    const { arguments: args, callee } = node;
+    const isRequiredModule = ((_a = args[0]) === null || _a === void 0 ? void 0 : _a.type) === 'StringLiteral' && isRequirePath(args[0], requirePath);
+    return isRequireCall(callee) && isRequiredModule;
+};
+exports.isRequire = isRequire;
+const isRequireCall = (node) => node.type === 'Identifier' && node.name === 'require';
+const isRequirePath = (node, path) => node.type === 'StringLiteral' && node.value === path;
+//# sourceMappingURL=helpers.js.map

package/dist/runtimes/node/parser/imports.d.ts

@@ -0,0 +1,6 @@
+import { Statement } from '@babel/types';
+declare const getImports: (node: Statement, importPath: string) => {
+    imported: string;
+    local: string;
+}[];
+export { getImports };

package/dist/runtimes/node/parser/imports.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImports = void 0;
+const non_nullable_1 = require("../../../utils/non_nullable");
+const helpers_1 = require("./helpers");
+// Finds import/require statements of a given path in an AST.
+const getImports = (node, importPath) => {
+    const esmImports = getImportsFromESM(node, importPath);
+    if (esmImports.length !== 0) {
+        return esmImports;
+    }
+    const cjsImports = getImportsFromCJS(node, importPath);
+    return cjsImports;
+};
+exports.getImports = getImports;
+// Finds import/require statements of a given path in a CJS AST.
+const getImportsFromCJS = (node, importPath) => {
+    if (node.type !== 'VariableDeclaration') {
+        return [];
+    }
+    const { declarations } = node;
+    const requireDeclaration = declarations.find((declaration) => declaration.type === 'VariableDeclarator' && (0, helpers_1.isRequire)(declaration.init, importPath));
+    if (requireDeclaration === undefined || requireDeclaration.id.type !== 'ObjectPattern') {
+        return [];
+    }
+    const imports = requireDeclaration.id.properties
+        .map((property) => {
+        if (property.type !== 'ObjectProperty') {
+            return;
+        }
+        const { key, value } = property;
+        if (key.type !== 'Identifier' || value.type !== 'Identifier') {
+            return;
+        }
+        return { imported: key.name, local: value.name };
+    })
+        .filter(non_nullable_1.nonNullable);
+    return imports;
+};
+// Finds import/require statements of a given path in an ESM AST.
+const getImportsFromESM = (node, importPath) => {
+    if (!(0, helpers_1.isImport)(node, importPath)) {
+        return [];
+    }
+    const { specifiers } = node;
+    const imports = specifiers
+        .map((specifier) => {
+        if (specifier.type !== 'ImportSpecifier') {
+            return;
+        }
+        const { imported, local } = specifier;
+        if (imported.type !== 'Identifier' || local.type !== 'Identifier') {
+            return;
+        }
+        return { imported: imported.name, local: local.name };
+    })
+        .filter(non_nullable_1.nonNullable);
+    return imports;
+};
+//# sourceMappingURL=imports.js.map

package/dist/runtimes/node/parser/index.d.ts

@@ -6,4 +6,5 @@ declare const parseExpression: ({ basePath, expression: rawExpression, resolveDi
     includedPathsGlob: string | null | undefined;
     type: string;
 } | undefined;
-export { parseExpression };
+declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;
+export { parseExpression, safelyParseFile };

package/dist/runtimes/node/parser/index.js

@@ -1,8 +1,19 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseExpression = void 0;
+exports.safelyParseFile = exports.parseExpression = void 0;
+/* eslint-disable max-lines */
 const path_1 = require("path");
 const parser_1 = require("@babel/parser");
+const fs_1 = require("../../../utils/fs");
 const non_nullable_1 = require("../../../utils/non_nullable");
 const GLOB_WILDCARD = '**';
 // Transforms an array of glob nodes into a glob string including an absolute
@@ -75,6 +86,29 @@ const parseExpression = ({ basePath, expression: rawExpression, resolveDir, }) =
     }
 };
 exports.parseExpression = parseExpression;
+// Parses a JS/TS file and returns the resulting AST.
+const parseFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    const code = yield (0, fs_1.readFile)(path, 'utf8');
+    const ast = (0, parser_1.parse)(code, {
+        plugins: ['typescript'],
+        sourceType: 'module',
+    });
+    return ast.program;
+});
+// Attemps to parse a JS/TS file at the given path, returning its AST if
+// successful, or `null` if not.
+const safelyParseFile = (path) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!path) {
+        return null;
+    }
+    try {
+        return yield parseFile(path);
+    }
+    catch (error) {
+        return null;
+    }
+});
+exports.safelyParseFile = safelyParseFile;
 // Parses a `require()` and returns a glob string with an absolute path.
 const parseRequire = ({ basePath, expression, resolveDir, }) => {
     const { arguments: args = [] } = expression;
@@ -146,4 +180,5 @@ const validateGlobNodes = (globNodes) => {
     const hasStaticHead = globNodes[0] !== GLOB_WILDCARD;
     return hasStrings && hasStaticHead;
 };
+/* eslint-enable max-lines */
 //# sourceMappingURL=index.js.map

package/dist/runtimes/runtime.d.ts

@@ -4,12 +4,17 @@ import { FeatureFlags } from '../feature_flags';
 import { FunctionSource, SourceFile } from '../function';
 import { FsCache } from '../utils/fs';
 import type { NodeBundlerName } from './node';
+import type { ISCValues } from './node/in_source_config';
 declare type RuntimeName = 'go' | 'js' | 'rs';
 declare type FindFunctionsInPathsFunction = (args: {
     featureFlags: FeatureFlags;
     fsCache: FsCache;
     paths: string[];
 }) => Promise<SourceFile[]>;
+declare type GetFunctionAtPathFunction = (path: string, args: {
+    featureFlags: FeatureFlags;
+    fsCache: FsCache;
+}) => Promise<SourceFile | undefined>;
 declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
@@ -22,6 +27,7 @@ interface ZipFunctionResult {
     bundlerWarnings?: object[];
     config: FunctionConfig;
     inputs?: string[];
+    inSourceConfig?: ISCValues;
     nativeNodeModules?: object;
     nodeModulesWithDynamicImports?: string[];
     path: string;
@@ -36,8 +42,9 @@ declare type ZipFunction = (args: {
 } & FunctionSource) => Promise<ZipFunctionResult>;
 interface Runtime {
     findFunctionsInPaths: FindFunctionsInPathsFunction;
+    getFunctionAtPath: GetFunctionAtPathFunction;
     getSrcFiles?: GetSrcFilesFunction;
     name: RuntimeName;
     zipFunction: ZipFunction;
 }
-export { FindFunctionsInPathsFunction, GetSrcFilesFunction, Runtime, RuntimeName, ZipFunction, ZipFunctionResult };
+export { FindFunctionsInPathsFunction, GetSrcFilesFunction, Runtime, RuntimeName, ZipFunction, ZipFunctionResult, GetFunctionAtPathFunction, };

package/dist/runtimes/rust/index.js

@@ -41,22 +41,28 @@ const detectRustFunction = ({ fsCache, path }) => __awaiter(void 0, void 0, void
 });
 const findFunctionsInPaths = function ({ featureFlags, fsCache, paths, }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const functions = yield Promise.all(paths.map((path) => __awaiter(this, void 0, void 0, function* () {
-            const runtime = yield (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
-            if (runtime === 'rs') {
-                return processBinary({ fsCache, path });
-            }
-            if (featureFlags.buildRustSource !== true) {
-                return;
-            }
-            const rustSourceFile = yield detectRustFunction({ fsCache, path });
-            if (rustSourceFile) {
-                return processSource({ fsCache, mainFile: rustSourceFile, path });
-            }
+        const functions = yield Promise.all(paths.map((path) => getFunctionAtPath(path, {
+            featureFlags,
+            fsCache,
         })));
         return functions.filter(non_nullable_1.nonNullable);
     });
 };
+const getFunctionAtPath = function (path, { featureFlags, fsCache, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const runtime = yield (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+        if (runtime === 'rs') {
+            return processBinary({ fsCache, path });
+        }
+        if (featureFlags.buildRustSource !== true) {
+            return;
+        }
+        const rustSourceFile = yield detectRustFunction({ fsCache, path });
+        if (rustSourceFile) {
+            return processSource({ fsCache, mainFile: rustSourceFile, path });
+        }
+    });
+};
 const processBinary = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
     const stat = (yield (0, fs_1.cachedLstat)(fsCache, path));
     const filename = (0, path_1.basename)(path);
@@ -116,6 +122,6 @@ const zipFunction = function ({ config, destFolder, filename, mainFile, runtime,
         return { config, path: destPath };
     });
 };
-const runtime = { findFunctionsInPaths, name: 'rs', zipFunction };
+const runtime = { findFunctionsInPaths, getFunctionAtPath, name: 'rs', zipFunction };
 exports.default = runtime;
 //# sourceMappingURL=index.js.map

package/dist/utils/format_result.js

@@ -4,8 +4,8 @@ exports.formatZipResult = void 0;
 const remove_undefined_1 = require("./remove_undefined");
 // Takes the result of zipping a function and formats it for output.
 const formatZipResult = (archive) => {
-    var _a;
-    const functionResult = Object.assign(Object.assign({}, archive), { runtime: archive.runtime.name, schedule: (_a = archive === null || archive === void 0 ? void 0 : archive.config) === null || _a === void 0 ? void 0 : _a.schedule });
+    var _a, _b, _c;
+    const functionResult = Object.assign(Object.assign({}, archive), { inSourceConfig: undefined, runtime: archive.runtime.name, schedule: (_b = (_a = archive.inSourceConfig) === null || _a === void 0 ? void 0 : _a.schedule) !== null && _b !== void 0 ? _b : (_c = archive === null || archive === void 0 ? void 0 : archive.config) === null || _c === void 0 ? void 0 : _c.schedule });
     return (0, remove_undefined_1.removeUndefined)(functionResult);
 };
 exports.formatZipResult = formatZipResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.0.0",
+  "version": "5.4.0-isc-listfunctions",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -93,7 +93,7 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^3.3.8",
+    "@netlify/eslint-config-node": "^4.0.1",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",