@netlify/zip-it-and-ship-it 4.28.1 → 4.28.2

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

@@ -15,6 +15,7 @@ declare type BundleFunction = (args: {
     repositoryRoot?: string;
 } & FunctionSource) => Promise<{
     aliases?: Map<string, string>;
+    rewrites?: Map<string, string>;
     basePath: string;
     bundlerWarnings?: BundlerWarning[];
     cleanupFunction?: CleanupFunction;

package/dist/runtimes/node/bundlers/nft/es_modules.d.ts

@@ -0,0 +1,4 @@
+import { NodeFileTraceReasons } from '@vercel/nft';
+import { FsCache } from '../../../../utils/fs';
+declare const getPatchedESMPackages: (esmPaths: Set<string>, reasons: NodeFileTraceReasons, fsCache: FsCache, basePath?: string | undefined) => Promise<Map<any, any>>;
+export { getPatchedESMPackages };

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

@@ -0,0 +1,43 @@
+"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.getPatchedESMPackages = void 0;
+const path_1 = require("path");
+const fs_1 = require("../../../../utils/fs");
+const getESMPackageJsons = (esmPaths, reasons, basePath) => {
+    const packageJsons = [...reasons.entries()]
+        .filter(([, reason]) => {
+        if (reason.type !== 'resolve') {
+            return false;
+        }
+        const hasESMParent = [...reason.parents].some((parentPath) => esmPaths.has(parentPath));
+        return hasESMParent;
+    })
+        .map(([path]) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
+    return packageJsons;
+};
+const getPatchedESMPackages = (esmPaths, reasons, fsCache, basePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const packages = getESMPackageJsons(esmPaths, reasons, basePath);
+    const patchedPackages = yield Promise.all(packages.map((path) => patchESMPackage(path, fsCache)));
+    const patchedPackagesMap = new Map();
+    packages.forEach((packagePath, index) => {
+        patchedPackagesMap.set(packagePath, patchedPackages[index]);
+    });
+    return patchedPackagesMap;
+});
+exports.getPatchedESMPackages = getPatchedESMPackages;
+const patchESMPackage = (path, fsCache) => __awaiter(void 0, void 0, void 0, function* () {
+    const file = (yield (0, fs_1.cachedReadFile)(fsCache, path, 'utf8'));
+    const packageJson = JSON.parse(file);
+    const patchedPackageJson = Object.assign(Object.assign({}, packageJson), { type: 'commonjs' });
+    return JSON.stringify(patchedPackageJson);
+});
+//# sourceMappingURL=es_modules.js.map

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

@@ -20,6 +20,7 @@ const unixify_1 = __importDefault(require("unixify"));
 const fs_1 = require("../../../../utils/fs");
 const base_path_1 = require("../../utils/base_path");
 const included_files_1 = require("../../utils/included_files");
+const es_modules_1 = require("./es_modules");
 const transpile_1 = require("./transpile");
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
@@ -27,7 +28,7 @@ const appearsToBeModuleName = (name) => !name.startsWith('.');
 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 { cleanupFunction, paths: dependencyPaths, transpilation, } = yield traceFilesAndTranspile({
+    const { paths: dependencyPaths, rewrites } = yield traceFilesAndTranspile({
         basePath: repositoryRoot,
         config,
         mainFile,
@@ -36,13 +37,12 @@ const bundle = ({ basePath, config, mainFile, pluginsModulesPath, repositoryRoot
     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();
     // Sorting the array to make the checksum deterministic.
-    const srcFiles = [...filteredIncludedPaths, ...transpilation.keys()].sort();
+    const srcFiles = [...filteredIncludedPaths].sort();
     return {
-        aliases: transpilation,
         basePath: (0, base_path_1.getBasePath)(dirnames),
-        cleanupFunction,
         inputs: dependencyPaths,
         mainFile,
+        rewrites,
         srcFiles,
     };
 });
@@ -52,13 +52,10 @@ const ignoreFunction = (path) => {
     return shouldIgnore;
 };
 const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsModulesPath, }) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         const fsCache = {};
-        const cache = {};
-        const { fileList: dependencyPaths } = yield (0, nft_1.nodeFileTrace)([mainFile], {
+        const { fileList: dependencyPaths, esmFileList, reasons, } = yield (0, nft_1.nodeFileTrace)([mainFile], {
             base: basePath,
-            cache,
             ignore: ignoreFunction,
             readFile: (path) => __awaiter(this, void 0, void 0, function* () {
                 try {
@@ -89,26 +86,13 @@ const traceFilesAndTranspile = function ({ basePath, config, mainFile, pluginsMo
             }),
         });
         const normalizedDependencyPaths = [...dependencyPaths].map((path) => basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path));
-        // We look at the cache object to find any paths corresponding to ESM files.
-        const esmPaths = [...(((_a = cache.analysisCache) === null || _a === void 0 ? void 0 : _a.entries()) || [])].filter(([, { isESM }]) => isESM).map(([path]) => path);
-        // After transpiling the ESM files, we get back a `Map` mapping the path of
-        // each transpiled to its original path.
-        const transpilation = yield (0, transpile_1.transpileMany)(esmPaths, config);
-        // Creating a `Set` with the original paths of the transpiled files so that
-        // we can do a O(1) lookup.
-        const originalPaths = new Set(transpilation.values());
-        // We remove the transpiled paths from the list of traced files, otherwise we
-        // would end up with duplicate files in the archive.
-        const filteredDependencyPaths = normalizedDependencyPaths.filter((path) => !originalPaths.has(path));
-        // The cleanup function will delete all the temporary files that were created
-        // as part of the transpilation process.
-        const cleanupFunction = () => __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([...transpilation.keys()].map(fs_1.safeUnlink));
-        });
+        const esmPaths = [...esmFileList].map((path) => (basePath ? (0, path_1.resolve)(basePath, path) : (0, path_1.resolve)(path)));
+        const transpiledPaths = yield (0, transpile_1.transpileMany)(esmPaths, config);
+        const patchedESMPackages = yield (0, es_modules_1.getPatchedESMPackages)(esmFileList, reasons, fsCache, basePath);
+        const rewrites = new Map([...transpiledPaths, ...patchedESMPackages]);
         return {
-            cleanupFunction,
-            paths: filteredDependencyPaths,
-            transpilation,
+            paths: normalizedDependencyPaths,
+            rewrites,
         };
     });
 };

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

@@ -11,34 +11,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transpileMany = void 0;
 const esbuild_1 = require("@netlify/esbuild");
-const tmp_promise_1 = require("tmp-promise");
-const fs_1 = require("../../../../utils/fs");
 const bundler_target_1 = require("../esbuild/bundler_target");
 const transpile = (path, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const targetPath = yield (0, tmp_promise_1.tmpName)({ postfix: '.js' });
-    const cleanupFn = () => (0, fs_1.safeUnlink)(targetPath);
     // The version of ECMAScript to use as the build target. This will determine
     // whether certain features are transpiled down or left untransformed.
     const nodeTarget = (0, bundler_target_1.getBundlerTarget)(config.nodeVersion);
-    yield (0, esbuild_1.build)({
+    const transpiled = yield (0, esbuild_1.build)({
         bundle: false,
         entryPoints: [path],
         format: 'cjs',
         logLevel: 'error',
-        outfile: targetPath,
         platform: 'node',
         target: [nodeTarget],
+        write: false,
     });
-    return {
-        cleanupFn,
-        path: targetPath,
-    };
+    return transpiled.outputFiles[0].text;
 });
 const transpileMany = (paths, config) => __awaiter(void 0, void 0, void 0, function* () {
     const transpiledPaths = new Map();
     yield Promise.all(paths.map((path) => __awaiter(void 0, void 0, void 0, function* () {
         const transpiled = yield transpile(path, config);
-        transpiledPaths.set(transpiled.path, path);
+        transpiledPaths.set(path, transpiled);
     })));
     return transpiledPaths;
 });

package/dist/runtimes/node/index.js

@@ -70,7 +70,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             yield (0, cp_file_1.default)(srcPath, destPath);
             return { config, path: destPath };
         }
-        const { aliases, cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, srcFiles, } = yield bundler.bundle({
+        const { aliases, cleanupFunction, basePath: finalBasePath, bundlerWarnings, inputs, mainFile: finalMainFile = mainFile, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = yield bundler.bundle({
             basePath,
             config,
             extension,
@@ -94,6 +94,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             filename,
             mainFile: finalMainFile,
             pluginsModulesPath,
+            rewrites,
             srcFiles,
         });
         yield (cleanupFunction === null || cleanupFunction === void 0 ? void 0 : cleanupFunction());

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

@@ -11,6 +11,7 @@ interface PackageJson {
     files?: string[];
     gypfile?: boolean;
     binary?: boolean;
+    type?: string;
 }
 declare const getPackageJson: (srcDir: string) => Promise<PackageJson>;
 export { getPackageJson, PackageJson };

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

@@ -7,6 +7,7 @@ interface ZipNodeParameters {
     filename: string;
     mainFile: string;
     pluginsModulesPath?: string;
+    rewrites?: Map<string, string>;
     srcFiles: string[];
 }
 declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {

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

@@ -43,7 +43,7 @@ const COPY_FILE_CONCURRENCY = os_1.default.cpus().length === 0 ? 2 : os_1.defaul
 // Sub-directory to place all user-defined files  (i.e. everything other than
 // the entry file generated by zip-it-and-ship-it).
 const DEFAULT_USER_SUBDIRECTORY = 'src';
-const createDirectory = function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, srcFiles, }) {
+const createDirectory = function ({ aliases = new Map(), basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, rewrites = new Map(), srcFiles, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const { contents: entryContents, filename: entryFilename } = getEntryFile({
             commonPrefix: basePath,
@@ -59,20 +59,23 @@ const createDirectory = function ({ aliases = new Map(), basePath, destFolder, e
         yield pWriteFile((0, path_1.join)(functionFolder, entryFilename), entryContents);
         // Copying source files.
         yield (0, p_map_1.default)(srcFiles, (srcFile) => {
-            const srcPath = aliases.get(srcFile) || srcFile;
-            const normalizedSrcPath = normalizeFilePath({
+            const destPath = aliases.get(srcFile) || srcFile;
+            const normalizedDestPath = normalizeFilePath({
                 commonPrefix: basePath,
-                path: srcPath,
+                path: destPath,
                 pluginsModulesPath,
                 userNamespace: DEFAULT_USER_SUBDIRECTORY,
             });
-            const destPath = (0, path_1.join)(functionFolder, normalizedSrcPath);
-            return (0, cp_file_1.default)(srcFile, destPath);
+            const absoluteDestPath = (0, path_1.join)(functionFolder, normalizedDestPath);
+            if (rewrites.has(srcFile)) {
+                return pWriteFile(absoluteDestPath, rewrites.get(srcFile));
+            }
+            return (0, cp_file_1.default)(srcFile, absoluteDestPath);
         }, { concurrency: COPY_FILE_CONCURRENCY });
         return functionFolder;
     });
 };
-const createZipArchive = function ({ aliases, basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, srcFiles, }) {
+const createZipArchive = function ({ aliases, basePath, destFolder, extension, filename, mainFile, pluginsModulesPath, rewrites, srcFiles, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const destPath = (0, path_1.join)(destFolder, `${(0, path_1.basename)(filename, extension)}.zip`);
         const { archive, output } = (0, archive_1.startZip)(destPath);
@@ -96,7 +99,16 @@ const createZipArchive = function ({ aliases, basePath, destFolder, extension, f
         // We ensure this is not async, so that the archive's checksum is
         // deterministic. Otherwise it depends on the order the files were added.
         srcFilesInfos.forEach(({ srcFile, stat }) => {
-            zipJsFile({ srcFile, commonPrefix: basePath, pluginsModulesPath, archive, stat, aliases, userNamespace });
+            zipJsFile({
+                aliases,
+                archive,
+                commonPrefix: basePath,
+                pluginsModulesPath,
+                rewrites,
+                srcFile,
+                stat,
+                userNamespace,
+            });
         });
         yield (0, archive_1.endZip)(archive, output);
         return destPath;
@@ -129,10 +141,15 @@ const getEntryFile = ({ commonPrefix, filename, mainFile, userNamespace, }) => {
         filename: entryFilename,
     };
 };
-const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, pluginsModulesPath, stat, srcFile, userNamespace, }) {
-    const filename = aliases.get(srcFile) || srcFile;
-    const normalizedFilename = normalizeFilePath({ commonPrefix, path: filename, pluginsModulesPath, userNamespace });
-    (0, archive_1.addZipFile)(archive, srcFile, normalizedFilename, stat);
+const zipJsFile = function ({ aliases = new Map(), archive, commonPrefix, pluginsModulesPath, rewrites = new Map(), stat, srcFile, userNamespace, }) {
+    const destPath = aliases.get(srcFile) || srcFile;
+    const normalizedDestPath = normalizeFilePath({ commonPrefix, path: destPath, pluginsModulesPath, userNamespace });
+    if (rewrites.has(srcFile)) {
+        (0, archive_1.addZipContent)(archive, rewrites.get(srcFile), normalizedDestPath);
+    }
+    else {
+        (0, archive_1.addZipFile)(archive, srcFile, normalizedDestPath, stat);
+    }
 };
 // `adm-zip` and `require()` expect Unix paths.
 // We remove the common path prefix.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "4.28.1",
+  "version": "4.28.2",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -94,7 +94,7 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^3.3.4",
+    "@netlify/eslint-config-node": "^3.3.5",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",