@netlify/zip-it-and-ship-it 16.1.0 → 16.2.0

package/dist/main.d.ts

@@ -5,8 +5,9 @@ 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 { bundle, zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
-export type { BundleOptions, BundleResult, FunctionsOptions, ServerOptions, ServerResult } from './zip.js';
+export { zipFunction, zipFunctions, zipServer, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
+export type { ServerOptions, ServerResult, ZipServerOptions } from './zip.js';
+export { findServerEntry } from './server.js';
 export type { FunctionsBag, MixedPaths } from './paths.js';
 export { ArchiveFormat, ARCHIVE_FORMAT } from './archive.js';
 export type { TrafficRules } from './rate_limit.js';
@@ -14,7 +15,7 @@ export type { ExtendedRoute, Route } from './utils/routes.js';
 export { NodeBundlerName, NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 export { RuntimeName, RUNTIME } from './runtimes/runtime.js';
 export { ModuleFormat, MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
-export { Manifest } from './manifest.js';
+export type { FunctionsManifest, Manifest, ServerManifest } from './manifest.js';
 export { FunctionResult } from './utils/format_result.js';
 export interface ListedFunction {
     name: string;

package/dist/main.js

@@ -6,7 +6,8 @@ import { parseFile } from './runtimes/node/in_source_config/index.js';
 import { RUNTIME } from './runtimes/runtime.js';
 import { RuntimeCache } from './utils/cache.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
-export { bundle, zipFunction, zipFunctions } from './zip.js';
+export { zipFunction, zipFunctions, zipServer } from './zip.js';
+export { findServerEntry } from './server.js';
 export { ARCHIVE_FORMAT } from './archive.js';
 export { NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 export { RUNTIME } from './runtimes/runtime.js';

package/dist/manifest.d.ts

@@ -37,9 +37,7 @@ interface ManifestServer {
     runtimeVersion?: string;
     vcpu?: number;
 }
-export interface Manifest {
-    functions: ManifestFunction[];
-    server?: ManifestServer;
+interface ManifestBase {
     system: {
         arch: string;
         platform: string;
@@ -47,9 +45,29 @@ export interface Manifest {
     timestamp: number;
     version: number;
 }
-export declare const createManifest: ({ functions, path, server, }: {
+export interface FunctionsManifest extends ManifestBase {
+    functions: ManifestFunction[];
+    /**
+     * A server is described by its own manifest now. Nothing writes this any
+     * more; it is kept so that readers of manifests written before the split
+     * still compile.
+     */
+    server?: ManifestServer;
+}
+export interface ServerManifest extends ManifestBase {
+    server: ManifestServer;
+}
+/**
+ * The functions manifest, under the name it had before the server manifest was
+ * introduced, for backwards compatibility.
+ */
+export type Manifest = FunctionsManifest;
+export declare const createFunctionsManifest: ({ functions, path }: {
     functions: FunctionResult[];
     path: string;
-    server?: ServerResult;
+}) => Promise<void>;
+export declare const createServerManifest: ({ path, server }: {
+    path: string;
+    server: ServerResult;
 }) => Promise<void>;
 export {};

package/dist/manifest.js

@@ -2,10 +2,19 @@ import { promises as fs } from 'fs';
 import { resolve } from 'path';
 import { arch, platform } from 'process';
 const MANIFEST_VERSION = 1;
-export const createManifest = async ({ functions, path, server, }) => {
+export const createFunctionsManifest = async ({ functions, path }) => {
+    const formattedFunctions = functions.map((func) => formatFunctionForManifest(func));
     const payload = {
-        functions: functions.map((func) => formatFunctionForManifest(func)),
-        server: server && formatServerForManifest(server),
+        functions: formattedFunctions,
+        system: { arch, platform },
+        timestamp: Date.now(),
+        version: MANIFEST_VERSION,
+    };
+    await fs.writeFile(path, JSON.stringify(payload));
+};
+export const createServerManifest = async ({ path, server }) => {
+    const payload = {
+        server: formatServerForManifest(server),
         system: { arch, platform },
         timestamp: Date.now(),
         version: MANIFEST_VERSION,

package/dist/server.d.ts

@@ -1,13 +1,13 @@
 import type { FeatureFlags } from './feature_flags.js';
-import type { RuntimeName } from './runtimes/runtime.js';
+import { type RuntimeName } from './runtimes/runtime.js';
 import type { RuntimeCache } from './utils/cache.js';
 import type { getLogger } from './utils/logger.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 /**
- * A bundled Netlify Server. It is built like a function, but it is described on
- * its own terms: it carries no schedule, event subscriptions, invocation mode,
- * priority or timeout, because it is not invoked per request.
+ * Resolves the server entrypoint inside `directory`, or undefined when there is
+ * none.
  */
+export declare const findServerEntry: (directory: string) => Promise<string | undefined>;
 export type ServerResult = {
     bundler?: string;
     excludedRoutes?: Route[];
@@ -22,8 +22,7 @@ export type ServerResult = {
     vcpu?: number;
 };
 /**
- * The deploy's Netlify Server, and how to bundle it. Set by whatever generates
- * the server, not by the user.
+ * The deploy's Netlify Server, and how to bundle it.
  */
 export interface ServerOptions {
     /**

package/dist/server.js

@@ -1,42 +1,72 @@
 import { promises as fs } from 'fs';
 import { extname, join, resolve } from 'path';
 import { ARCHIVE_FORMAT } from './archive.js';
+import { NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 import { getFunctionFromPath } from './runtimes/index.js';
+import { RUNTIME } from './runtimes/runtime.js';
+import { FunctionBundlingUserError } from './utils/error.js';
 import { formatZipResult } from './utils/format_result.js';
 import { removeUndefined } from './utils/remove_undefined.js';
 import { getRoutes } from './utils/routes.js';
 // A server claims every path the rest of the deploy does not.
 const SERVER_ROUTE = '/*';
-// Names the server's output folder and its archive.
+// Names the server's archive. Everywhere else it is only a label, identifying
+// the server in bundling errors, since a server has no name of its own.
 const SERVER_NAME = 'server';
-// A server that cannot be read leaves the deploy with no backend at all, so it
-// fails the build rather than coming up empty.
+const SERVER_ENTRY_BASENAMES = new Set(['index.js', 'index.mjs', 'index.ts', 'index.mts']);
+/**
+ * Resolves the server entrypoint inside `directory`, or undefined when there is
+ * none.
+ */
+export const findServerEntry = async (directory) => {
+    let entries;
+    try {
+        entries = await fs.readdir(directory);
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === 'ENOENT' || code === 'ENOTDIR') {
+            return undefined;
+        }
+        throw error;
+    }
+    const candidates = entries.filter((name) => SERVER_ENTRY_BASENAMES.has(name)).sort();
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    if (candidates.length > 1) {
+        throw new Error(`Found multiple server entrypoints in ${directory} (${candidates.join(', ')}). A site can have one server only.`);
+    }
+    return join(directory, candidates[0]);
+};
 const readServerSource = async (srcPath, { cache, featureFlags }) => {
     let source;
+    // A server that cannot be read is the user's file being wrong, so it is
+    // reported as a bundling failure rather than an internal error.
+    const unreadable = (detail) => new FunctionBundlingUserError(`Could not read the Netlify Server at ${srcPath}${detail ? `: ${detail}` : ''}`, {
+        functionName: SERVER_NAME,
+        runtime: RUNTIME.JAVASCRIPT,
+    });
     try {
         source = await getFunctionFromPath(srcPath, { cache, featureFlags });
     }
     catch (error) {
-        throw new Error(`Could not read the Netlify Server at ${srcPath}: ${error.message}`);
+        throw unreadable(error.message);
     }
     if (source === undefined) {
-        throw new Error(`Could not read the Netlify Server at ${srcPath}`);
+        throw unreadable();
     }
     return source;
 };
-// Bundles a Netlify Server through the same runtime as a function, into its own
-// folder so its archive does not land among theirs.
 export const bundleServer = async (server, destFolder, { basePath, cache, featureFlags, logger, repositoryRoot, }) => {
     const srcPath = resolve(server.path);
     const source = await readServerSource(srcPath, { cache, featureFlags });
-    const serverFolder = join(destFolder, SERVER_NAME);
-    await fs.mkdir(serverFolder, { recursive: true });
     const zipResult = await source.runtime.zipFunction({
         archiveFormat: ARCHIVE_FORMAT.ZIP,
         basePath,
         cache,
-        config: source.config,
-        destFolder: serverFolder,
+        config: { ...source.config, nodeBundler: NODE_BUNDLER.NFT },
+        destFolder,
         extension: source.extension,
         featureFlags,
         filename: source.filename,
@@ -51,7 +81,7 @@ export const bundleServer = async (server, destFolder, { basePath, cache, featur
         srcPath,
         stat: source.stat,
     });
-    const path = join(serverFolder, `${SERVER_NAME}${extname(zipResult.path)}`);
+    const path = join(destFolder, `${SERVER_NAME}${extname(zipResult.path)}`);
     await fs.rename(zipResult.path, path);
     const result = formatZipResult({
         ...zipResult,

package/dist/zip.d.ts

@@ -17,53 +17,23 @@ export interface ZipFunctionOptions {
     debug?: boolean;
     internalSrcFolder?: string;
 }
-export interface BundleResult {
-    /**
-     * The bundled functions. A server is never among them.
-     */
-    functions: FunctionResult[];
-    /**
-     * The bundled Netlify Server, when one was given.
-     */
-    server?: ServerResult;
-}
 export type ZipFunctionsOptions = ZipFunctionOptions & {
     configFileDirectories?: string[];
     manifest?: string;
     parallelLimit?: number;
 };
-/**
- * The deploy's functions, and how to bundle them.
- */
-export interface FunctionsOptions {
-    /**
-     * Directories to search, specific function paths, or both.
-     */
-    paths: MixedPaths;
-    archiveFormat?: ArchiveFormat;
-    config?: Config;
-    configFileDirectories?: string[];
-    parallelLimit?: number;
-}
-export type { ServerOptions, ServerResult };
-export interface BundleOptions {
-    /**
-     * Where the archives and the manifest are written.
-     */
-    destFolder: string;
-    functions?: FunctionsOptions;
-    server?: ServerOptions;
+export interface ZipServerOptions {
+    basePath?: string;
+    debug?: boolean;
+    featureFlags?: FeatureFlags;
     /**
      * Path of the manifest file. Defaults to `manifest.json` inside `destFolder`.
      */
     manifest?: string;
-    basePath?: string;
-    branch?: string;
-    debug?: boolean;
-    featureFlags?: FeatureFlags;
     repositoryRoot?: string;
     systemLog?: LogFunction;
 }
-export declare const zipFunctions: (input: MixedPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, debug, featureFlags, manifest, parallelLimit, repositoryRoot, systemLog, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
-export declare const bundle: ({ basePath, branch, debug, destFolder, featureFlags: inputFeatureFlags, functions: functionsOptions, manifest, repositoryRoot, server, systemLog, }: BundleOptions) => Promise<BundleResult>;
+export type { ServerOptions, ServerResult };
+export declare const zipFunctions: (input: MixedPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
+export declare const zipServer: (srcPath: string, destFolder: string, { basePath, debug, featureFlags: inputFeatureFlags, manifest, repositoryRoot, systemLog, }?: ZipServerOptions) => Promise<ServerResult>;
 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

@@ -4,7 +4,7 @@ import isPathInside from 'is-path-inside';
 import pMap from 'p-map';
 import { ARCHIVE_FORMAT } from './archive.js';
 import { getFlags } from './feature_flags.js';
-import { createManifest } from './manifest.js';
+import { createFunctionsManifest, createServerManifest } from './manifest.js';
 import { bundleServer } from './server.js';
 import { getFunctionsFromPaths } from './runtimes/index.js';
 import { MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
@@ -23,41 +23,15 @@ 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 (input, destFolder, { archiveFormat, basePath, branch, config, configFileDirectories, debug, featureFlags, manifest, parallelLimit, repositoryRoot, systemLog, } = {}) {
-    const { functions } = await bundle({
-        basePath,
-        branch,
-        debug,
-        destFolder,
-        featureFlags,
-        functions: {
-            archiveFormat,
-            config,
-            configFileDirectories,
-            parallelLimit,
-            paths: input,
-        },
-        manifest,
-        repositoryRoot,
-        systemLog,
-    });
-    return functions;
-};
-// Bundles a deploy's functions and its Netlify Server, writing the one manifest
-// that describes both.
-export const bundle = async function ({ basePath, branch, debug, destFolder, featureFlags: inputFeatureFlags, functions: functionsOptions, manifest, repositoryRoot = basePath, server, systemLog, }) {
-    const { archiveFormat = ARCHIVE_FORMAT.ZIP, config = {}, configFileDirectories, parallelLimit = DEFAULT_PARALLEL_LIMIT, paths, } = functionsOptions ?? { paths: [] };
+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 bag = getFunctionsBag(paths);
+    const bag = getFunctionsBag(input);
     const srcFolders = resolveFunctionsDirectories([...bag.generated.directories, ...bag.user.directories]);
-    const [foundPaths] = await Promise.all([
-        listFunctionsDirectories(srcFolders),
-        fs.mkdir(destFolder, { recursive: true }),
-    ]);
-    const functions = await getFunctionsFromPaths([...foundPaths, ...bag.generated.functions, ...bag.user.functions], {
+    const [paths] = await Promise.all([listFunctionsDirectories(srcFolders), fs.mkdir(destFolder, { recursive: true })]);
+    const functions = await getFunctionsFromPaths([...paths, ...bag.generated.functions, ...bag.user.functions], {
         cache,
         config,
         configFileDirectories,
@@ -101,21 +75,26 @@ export const bundle = async function ({ basePath, branch, debug, destFolder, fea
         const resultWithSize = await addArchiveSize(result);
         return formatZipResult(resultWithSize);
     }));
-    const serverResult = server === undefined
-        ? undefined
-        : await bundleServer(server, destFolder, {
-            basePath,
-            cache,
-            featureFlags,
-            logger,
-            repositoryRoot,
-        });
-    await createManifest({
+    await createFunctionsManifest({
         functions: formattedResults,
         path: resolve(manifest || join(destFolder, 'manifest.json')),
-        server: serverResult,
     });
-    return { functions: formattedResults, server: serverResult };
+    return formattedResults;
+};
+export const zipServer = async function (srcPath, destFolder, { basePath, debug, featureFlags: inputFeatureFlags, manifest, repositoryRoot = basePath, systemLog, } = {}) {
+    const logger = getLogger(systemLog, debug);
+    const cache = new RuntimeCache();
+    const featureFlags = getFlags(inputFeatureFlags);
+    await fs.mkdir(destFolder, { recursive: true });
+    const result = await bundleServer({ path: srcPath }, destFolder, {
+        basePath,
+        cache,
+        featureFlags,
+        logger,
+        repositoryRoot,
+    });
+    await createServerManifest({ path: resolve(manifest || join(destFolder, 'manifest.json')), server: result });
+    return result;
 };
 export const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = ARCHIVE_FORMAT.ZIP, basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, systemLog, debug, internalSrcFolder, } = {}) {
     validateArchiveFormat(archiveFormat);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "16.1.0",
+  "version": "16.2.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "22902a5992a5909a97bb366c88c96f6d95c18b33"
+  "gitHead": "b1c3e6b1ed61a7be7bc06e4a8e4b2e48f5882de3"
 }