@netlify/zip-it-and-ship-it 16.0.0 → 16.1.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 { zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
-export type { FunctionsBag } from './paths.js';
+export { bundle, zipFunction, zipFunctions, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
+export type { BundleOptions, BundleResult, FunctionsOptions, ServerOptions, ServerResult } from './zip.js';
+export type { FunctionsBag, MixedPaths } from './paths.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/main.js

@@ -6,7 +6,7 @@ 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 { zipFunction, zipFunctions } from './zip.js';
+export { bundle, zipFunction, zipFunctions } from './zip.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

@@ -1,5 +1,6 @@
 import type { InvocationMode } from './function.js';
 import type { TrafficRules } from './rate_limit.js';
+import type { ServerResult } from './server.js';
 import type { FunctionResult } from './utils/format_result.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 interface ManifestFunction {
@@ -24,8 +25,21 @@ interface ManifestFunction {
     trafficRules?: TrafficRules;
     vcpu?: number;
 }
+interface ManifestServer {
+    bundler?: string;
+    excludedRoutes?: Route[];
+    mainFile: string;
+    memory?: number;
+    path: string;
+    region?: string;
+    routes?: ExtendedRoute[];
+    runtime: string;
+    runtimeVersion?: string;
+    vcpu?: number;
+}
 export interface Manifest {
     functions: ManifestFunction[];
+    server?: ManifestServer;
     system: {
         arch: string;
         platform: string;
@@ -33,8 +47,9 @@ export interface Manifest {
     timestamp: number;
     version: number;
 }
-export declare const createManifest: ({ functions, path }: {
+export declare const createManifest: ({ functions, path, server, }: {
     functions: FunctionResult[];
     path: string;
+    server?: ServerResult;
 }) => Promise<void>;
 export {};

package/dist/manifest.js

@@ -2,16 +2,35 @@ 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 }) => {
-    const formattedFunctions = functions.map((func) => formatFunctionForManifest(func));
+export const createManifest = async ({ functions, path, server, }) => {
     const payload = {
-        functions: formattedFunctions,
+        functions: functions.map((func) => formatFunctionForManifest(func)),
+        server: server && formatServerForManifest(server),
         system: { arch, platform },
         timestamp: Date.now(),
         version: MANIFEST_VERSION,
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
+const formatServerForManifest = ({ bundler, excludedRoutes, mainFile, memory, path, region, routes, runtime, runtimeVersion, vcpu, }) => {
+    const server = {
+        bundler,
+        mainFile,
+        memory,
+        path: resolve(path),
+        region,
+        runtime,
+        runtimeVersion,
+        vcpu,
+    };
+    if (routes?.length) {
+        server.routes = routes;
+    }
+    if (excludedRoutes?.length) {
+        server.excludedRoutes = excludedRoutes;
+    }
+    return server;
+};
 const formatFunctionForManifest = ({ bootstrapVersion, bundler, displayName, eventSubscriptions, excludedRoutes, generator, invocationMode, mainFile, memory, name, path, priority, region, trafficRules, routes, runtime, runtimeVersion, runtimeAPIVersion, schedule, timeout, vcpu, }) => {
     const manifestFunction = {
         bundler,

package/dist/runtimes/node/index.js

@@ -32,7 +32,7 @@ const getSrcFilesWithBundler = async (parameters) => {
     const result = await bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
     return result.srcFiles;
 };
-const zipFunction = async function ({ archiveFormat, basePath, branch, cache, config = {}, destFolder, extension, featureFlags, filename, isInternal, logger, mainFile, name, repositoryRoot, runtime, span, srcDir, srcPath, stat, }) {
+const zipFunction = async function ({ archiveFormat, basePath, branch, cache, config = {}, destFolder, extension, featureFlags, filename, isInternal, isServer, logger, mainFile, name, repositoryRoot, runtime, span, srcDir, srcPath, stat, }) {
     // If the file is a zip, we assume the function is bundled and ready to go.
     // We simply copy it to the destination path with no further processing.
     if (extension === '.zip') {
@@ -106,6 +106,7 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
         extension,
         featureFlags,
         filename,
+        isServer,
         mainFile: finalMainFile,
         moduleFormat,
         name,

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

@@ -4,6 +4,7 @@ export declare const ENTRY_FILE_NAME = "___netlify-entry-point";
 export declare const BOOTSTRAP_FILE_NAME = "___netlify-bootstrap.mjs";
 export declare const METADATA_FILE_NAME = "___netlify-metadata.json";
 export declare const TELEMETRY_FILE_NAME = "___netlify-telemetry.mjs";
+export declare const SERVER_MARKER_FILENAME = "___netlify-server.json";
 export interface EntryFile {
     contents: string;
     filename: string;

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

@@ -9,6 +9,7 @@ export const ENTRY_FILE_NAME = '___netlify-entry-point';
 export const BOOTSTRAP_FILE_NAME = '___netlify-bootstrap.mjs';
 export const METADATA_FILE_NAME = '___netlify-metadata.json';
 export const TELEMETRY_FILE_NAME = '___netlify-telemetry.mjs';
+export const SERVER_MARKER_FILENAME = '___netlify-server.json';
 const require = createRequire(import.meta.url);
 /**
  * A minimal implementation of kebab-case.

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

@@ -11,6 +11,7 @@ interface ZipNodeParameters {
     extension: string;
     featureFlags: FeatureFlags;
     filename: string;
+    isServer?: boolean;
     mainFile: string;
     moduleFormat: ModuleFormat;
     name: string;

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

@@ -7,7 +7,7 @@ import { copyFile } from 'copy-file';
 import pMap from 'p-map';
 import { addZipContent, addZipFile, ARCHIVE_FORMAT, endZip, startTar, startZip, } from '../../../archive.js';
 import { cachedLstat, mkdirAndWriteFile } from '../../../utils/fs.js';
-import { BOOTSTRAP_FILE_NAME, METADATA_FILE_NAME, conflictsWithEntryFile, getEntryFile, getTelemetryFile, isNamedLikeEntryFile, } from './entry_file.js';
+import { BOOTSTRAP_FILE_NAME, METADATA_FILE_NAME, conflictsWithEntryFile, getEntryFile, getTelemetryFile, isNamedLikeEntryFile, SERVER_MARKER_FILENAME, } from './entry_file.js';
 import { NETLIFY_PLAY_BOOTSTRAP_VERSION, useNetlifyPlay } from './play.js';
 import { getMetadataFile } from './metadata_file.js';
 import { normalizeFilePath } from './normalize_path.js';
@@ -101,8 +101,8 @@ const createDirectory = async function ({ aliases = new Map(), basePath, cache,
     });
     return { path: functionFolder, entryFilename };
 };
-const createZipArchive = async function ({ aliases = new Map(), basePath, branch, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, runtimeAPIVersion, srcFiles, generator, }) {
-    const isPlay = useNetlifyPlay(featureFlags, mainFile);
+const createZipArchive = async function ({ aliases = new Map(), basePath, branch, cache, destFolder, extension, featureFlags, filename, isServer, mainFile, moduleFormat, rewrites, runtimeAPIVersion, srcFiles, generator, }) {
+    const isPlay = isServer === true || useNetlifyPlay(featureFlags, mainFile);
     const format = isPlay ? ARCHIVE_FORMAT.TAR : ARCHIVE_FORMAT.ZIP;
     const archiveExtension = format === ARCHIVE_FORMAT.TAR ? '.tgz' : '.zip';
     const destPath = join(destFolder, `${basename(filename, extension)}${archiveExtension}`);
@@ -141,6 +141,9 @@ const createZipArchive = async function ({ aliases = new Map(), basePath, branch
         entryFilename = entryFile.filename;
         addEntryFileToZip(archive, entryFile);
     }
+    if (isServer === true) {
+        addEntryFileToZip(archive, { contents: '{}', filename: SERVER_MARKER_FILENAME });
+    }
     const telemetryFile = getTelemetryFile(generator);
     if (featureFlags.zisi_add_instrumentation_loader === true) {
         addEntryFileToZip(archive, telemetryFile);

package/dist/runtimes/runtime.d.ts

@@ -66,6 +66,7 @@ export type ZipFunction = (args: {
     featureFlags: FeatureFlags;
     generator?: string;
     isInternal: boolean;
+    isServer?: boolean;
     logger: Logger;
     repositoryRoot?: string;
     span?: Span;

package/dist/server.d.ts

@@ -0,0 +1,40 @@
+import type { FeatureFlags } from './feature_flags.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.
+ */
+export type ServerResult = {
+    bundler?: string;
+    excludedRoutes?: Route[];
+    mainFile: string;
+    memory?: number;
+    path: string;
+    region?: string;
+    routes?: ExtendedRoute[];
+    runtime: RuntimeName;
+    runtimeVersion?: string;
+    size?: number;
+    vcpu?: number;
+};
+/**
+ * The deploy's Netlify Server, and how to bundle it. Set by whatever generates
+ * the server, not by the user.
+ */
+export interface ServerOptions {
+    /**
+     * Path of the user's server entry file.
+     */
+    path: string;
+}
+export declare const bundleServer: (server: ServerOptions, destFolder: string, { basePath, cache, featureFlags, logger, repositoryRoot, }: {
+    basePath?: string;
+    cache: RuntimeCache;
+    featureFlags: FeatureFlags;
+    logger: ReturnType<typeof getLogger>;
+    repositoryRoot?: string;
+}) => Promise<ServerResult>;

package/dist/server.js

@@ -0,0 +1,76 @@
+import { promises as fs } from 'fs';
+import { extname, join, resolve } from 'path';
+import { ARCHIVE_FORMAT } from './archive.js';
+import { getFunctionFromPath } from './runtimes/index.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.
+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 readServerSource = async (srcPath, { cache, featureFlags }) => {
+    let source;
+    try {
+        source = await getFunctionFromPath(srcPath, { cache, featureFlags });
+    }
+    catch (error) {
+        throw new Error(`Could not read the Netlify Server at ${srcPath}: ${error.message}`);
+    }
+    if (source === undefined) {
+        throw new Error(`Could not read the Netlify Server at ${srcPath}`);
+    }
+    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,
+        extension: source.extension,
+        featureFlags,
+        filename: source.filename,
+        isInternal: true,
+        isServer: true,
+        logger,
+        mainFile: source.mainFile,
+        name: SERVER_NAME,
+        repositoryRoot,
+        runtime: source.runtime,
+        srcDir: source.srcDir,
+        srcPath,
+        stat: source.stat,
+    });
+    const path = join(serverFolder, `${SERVER_NAME}${extname(zipResult.path)}`);
+    await fs.rename(zipResult.path, path);
+    const result = formatZipResult({
+        ...zipResult,
+        mainFile: source.mainFile,
+        name: SERVER_NAME,
+        path,
+        runtime: source.runtime,
+    });
+    return removeUndefined({
+        bundler: result.bundler,
+        excludedRoutes: result.excludedRoutes,
+        mainFile: result.mainFile,
+        memory: result.memory,
+        path: result.path,
+        region: result.region,
+        routes: getRoutes(SERVER_NAME, SERVER_ROUTE).map((route) => ({ ...route, prefer_static: true })),
+        runtime: result.runtime,
+        runtimeVersion: result.runtimeVersion,
+        size: result.size,
+        vcpu: result.vcpu,
+    });
+};

package/dist/zip.d.ts

@@ -1,6 +1,7 @@
 import { ArchiveFormat } from './archive.js';
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
+import { type ServerOptions, type ServerResult } from './server.js';
 import { type MixedPaths } from './paths.js';
 import { FunctionResult } from './utils/format_result.js';
 import { LogFunction } from './utils/logger.js';
@@ -16,10 +17,53 @@ 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;
 };
-export declare const zipFunctions: (input: MixedPaths, destFolder: string, { archiveFormat, basePath, branch, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<FunctionResult[]>;
+/**
+ * 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;
+    /**
+     * 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 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

@@ -5,6 +5,7 @@ import pMap from 'p-map';
 import { ARCHIVE_FORMAT } from './archive.js';
 import { getFlags } from './feature_flags.js';
 import { createManifest } from './manifest.js';
+import { bundleServer } from './server.js';
 import { getFunctionsFromPaths } from './runtimes/index.js';
 import { MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
 import { getFunctionsBag } from './paths.js';
@@ -22,15 +23,41 @@ 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 = ARCHIVE_FORMAT.ZIP, basePath, branch, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, } = {}) {
+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: [] };
     validateArchiveFormat(archiveFormat);
     const logger = getLogger(systemLog, debug);
     const cache = new RuntimeCache();
     const featureFlags = getFlags(inputFeatureFlags);
-    const bag = getFunctionsBag(input);
+    const bag = getFunctionsBag(paths);
     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, ...bag.generated.functions, ...bag.user.functions], {
+    const [foundPaths] = await Promise.all([
+        listFunctionsDirectories(srcFolders),
+        fs.mkdir(destFolder, { recursive: true }),
+    ]);
+    const functions = await getFunctionsFromPaths([...foundPaths, ...bag.generated.functions, ...bag.user.functions], {
         cache,
         config,
         configFileDirectories,
@@ -74,8 +101,21 @@ export const zipFunctions = async function (input, destFolder, { archiveFormat =
         const resultWithSize = await addArchiveSize(result);
         return formatZipResult(resultWithSize);
     }));
-    await createManifest({ functions: formattedResults, path: resolve(manifest || join(destFolder, 'manifest.json')) });
-    return formattedResults;
+    const serverResult = server === undefined
+        ? undefined
+        : await bundleServer(server, destFolder, {
+            basePath,
+            cache,
+            featureFlags,
+            logger,
+            repositoryRoot,
+        });
+    await createManifest({
+        functions: formattedResults,
+        path: resolve(manifest || join(destFolder, 'manifest.json')),
+        server: serverResult,
+    });
+    return { functions: formattedResults, server: serverResult };
 };
 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.0.0",
+  "version": "16.1.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "224d0ab995156edc7e7b08859cf651e2adfeacfa"
+  "gitHead": "22902a5992a5909a97bb366c88c96f6d95c18b33"
 }