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

package/dist/main.d.ts

@@ -5,15 +5,17 @@ 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 { 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';
 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 { 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

@@ -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,19 @@ interface ManifestFunction {
     trafficRules?: TrafficRules;
     vcpu?: number;
 }
-export interface Manifest {
-    functions: ManifestFunction[];
+interface ManifestServer {
+    bundler?: string;
+    excludedRoutes?: Route[];
+    mainFile: string;
+    memory?: number;
+    path: string;
+    region?: string;
+    routes?: ExtendedRoute[];
+    runtime: string;
+    runtimeVersion?: string;
+    vcpu?: number;
+}
+interface ManifestBase {
     system: {
         arch: string;
         platform: string;
@@ -33,8 +45,29 @@ export interface Manifest {
     timestamp: number;
     version: number;
 }
-export declare const createManifest: ({ functions, path }: {
+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;
 }) => Promise<void>;
+export declare const createServerManifest: ({ path, server }: {
+    path: string;
+    server: ServerResult;
+}) => Promise<void>;
 export {};

package/dist/manifest.js

@@ -2,7 +2,7 @@ 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 }) => {
+export const createFunctionsManifest = async ({ functions, path }) => {
     const formattedFunctions = functions.map((func) => formatFunctionForManifest(func));
     const payload = {
         functions: formattedFunctions,
@@ -12,6 +12,34 @@ export const createManifest = async ({ functions, path }) => {
     };
     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,
+    };
+    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,39 @@
+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';
+/**
+ * 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[];
+    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.
+ */
+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,106 @@
+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 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';
+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 unreadable(error.message);
+    }
+    if (source === undefined) {
+        throw unreadable();
+    }
+    return source;
+};
+export const bundleServer = async (server, destFolder, { basePath, cache, featureFlags, logger, repositoryRoot, }) => {
+    const srcPath = resolve(server.path);
+    const source = await readServerSource(srcPath, { cache, featureFlags });
+    const zipResult = await source.runtime.zipFunction({
+        archiveFormat: ARCHIVE_FORMAT.ZIP,
+        basePath,
+        cache,
+        config: { ...source.config, nodeBundler: NODE_BUNDLER.NFT },
+        destFolder,
+        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(destFolder, `${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';
@@ -21,5 +22,18 @@ export type ZipFunctionsOptions = ZipFunctionOptions & {
     manifest?: string;
     parallelLimit?: number;
 };
+export interface ZipServerOptions {
+    basePath?: string;
+    debug?: boolean;
+    featureFlags?: FeatureFlags;
+    /**
+     * Path of the manifest file. Defaults to `manifest.json` inside `destFolder`.
+     */
+    manifest?: string;
+    repositoryRoot?: string;
+    systemLog?: LogFunction;
+}
+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,8 @@ 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';
 import { getFunctionsBag } from './paths.js';
@@ -74,9 +75,27 @@ 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')) });
+    await createFunctionsManifest({
+        functions: formattedResults,
+        path: resolve(manifest || join(destFolder, 'manifest.json')),
+    });
     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);
     const logger = getLogger(systemLog, debug);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "16.0.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": "224d0ab995156edc7e7b08859cf651e2adfeacfa"
+  "gitHead": "b1c3e6b1ed61a7be7bc06e4a8e4b2e48f5882de3"
 }