@netlify/build 36.4.8 → 37.1.0

package/lib/core/feature_flags.js

@@ -16,4 +16,5 @@ export const DEFAULT_FEATURE_FLAGS = {
     edge_bundler_generate_tarball: false,
     netlify_build_db_setup: false,
     netlify_build_server_entry: false,
+    netlify_build_server_standalone: false,
 };

package/lib/core/normalize_flags.js

@@ -55,12 +55,9 @@ const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
         testOpts: {},
         featureFlags: DEFAULT_FEATURE_FLAGS,
         statsd: { port: DEFAULT_STATSD_PORT },
-        // tracing.apiKey defaults to '-' else we'll get warning logs if not using
-        // honeycomb directly - https://github.com/honeycombio/honeycomb-opentelemetry-node/issues/201
         tracing: {
             enabled: false,
             preloadingEnabled: false,
-            apiKey: '-',
             // defaults to always sample
             sampleRate: 1,
             httpProtocol: DEFAULT_OTEL_ENDPOINT_PROTOCOL,

package/lib/plugins_core/functions/index.d.ts

@@ -1,4 +1,4 @@
-import { zipFunctions, type FunctionResult } from '@netlify/zip-it-and-ship-it';
+import { type BundleOptions, type BundleResult, type FunctionResult, zipFunctions } from '@netlify/zip-it-and-ship-it';
 import type { CoreStepFunction } from '../types.js';
 export declare const bundleFunctions: {
     event: string;
@@ -18,5 +18,6 @@ export declare const bundleFunctions: {
     }) => Promise<boolean>;
 };
 export declare const zipItAndShipIt: {
-    zipFunctions(input: import("packages/zip-it-and-ship-it/dist/paths.js").MixedPaths, destFolder: string, args_2?: import("@netlify/zip-it-and-ship-it").ZipFunctionsOptions | undefined): Promise<FunctionResult[]>;
+    bundle(options: BundleOptions): Promise<BundleResult>;
+    zipFunctions(input: import("@netlify/zip-it-and-ship-it").MixedPaths, destFolder: string, args_2?: import("@netlify/zip-it-and-ship-it").ZipFunctionsOptions | undefined): Promise<FunctionResult[]>;
 };

package/lib/plugins_core/functions/index.js

@@ -1,5 +1,5 @@
 import { resolve } from 'path';
-import { zipFunctions } from '@netlify/zip-it-and-ship-it';
+import { bundle, zipFunctions, } from '@netlify/zip-it-and-ship-it';
 import { pathExists } from '../../utils/path_exists.js';
 import { addErrorInfo } from '../../error/info.js';
 import { log } from '../../log/logger.js';
@@ -7,7 +7,7 @@ import { getGeneratedFunctions } from '../../steps/return_values.js';
 import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle, trackBundleResults, } from '../../log/messages/core_steps.js';
 import { FRAMEWORKS_API_FUNCTIONS_PATH } from '../../utils/frameworks_api.js';
 import { getZipError } from './error.js';
-import { getServerEntry } from './server_entry.js';
+import { getServerEntry, useServer, writeServerShim } from './server_entry.js';
 import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js';
 import { getZisiParameters } from './zisi.js';
 // see https://docs.netlify.com/functions/trigger-on-events/#available-triggers
@@ -42,7 +42,7 @@ const validateCustomRoutes = function (functions) {
         }
     }
 };
-const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFlags, functionsConfig, functionsDist, functionsSrc, generatedFunctions, frameworkFunctionsSrc, internalFunctionsSrc, isRunningLocally, logs, repositoryRoot, userNodeVersion, systemLog, }) => {
+const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFlags, functionsConfig, functionsDist, functionsSrc, generatedFunctions, frameworkFunctionsSrc, internalFunctionsSrc, isRunningLocally, logs, repositoryRoot, server, userNodeVersion, systemLog, }) => {
     const zisiParameters = getZisiParameters({
         branch,
         buildDir,
@@ -52,14 +52,7 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
         functionsDist,
         internalFunctionsSrc,
         isRunningLocally,
-        repositoryRoot,
-        userNodeVersion,
-        systemLog,
-    });
-    try {
-        // Printing an empty line before bundling output.
-        log(logs, '');
-        const results = await zipItAndShipIt.zipFunctions({
+        paths: {
             generated: {
                 directories: [internalFunctionsSrc, frameworkFunctionsSrc].filter(Boolean),
                 functions: generatedFunctions,
@@ -67,7 +60,16 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
             user: {
                 directories: [functionsSrc].filter(Boolean),
             },
-        }, functionsDist, zisiParameters);
+        },
+        repositoryRoot,
+        server,
+        userNodeVersion,
+        systemLog,
+    });
+    try {
+        // Printing an empty line before bundling output.
+        log(logs, '');
+        const { functions: results } = await zipItAndShipIt.bundle(zisiParameters);
         validateCustomRoutes(results);
         logBundleResults({ logs, results });
         const summary = trackBundleResults({ results, systemLog });
@@ -106,6 +108,9 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
     if (serverEntry) {
         log(logs, `Netlify Server detected at ${serverEntry.relativeEntryPath}`);
     }
+    const asFunction = featureFlags?.netlify_build_server_entry === true;
+    const standalone = featureFlags?.netlify_build_server_standalone === true;
+    const serverShimPath = serverEntry && asFunction ? await writeServerShim(serverEntry) : undefined;
     logFunctionsToBundle({
         logs,
         userFunctions,
@@ -140,8 +145,9 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         systemLog,
         generatedFunctions: [
             ...generatedFunctions.map((func) => func.path),
-            ...(serverEntry ? [serverEntry.shimPath] : []),
+            ...(serverShimPath === undefined ? [] : [serverShimPath]),
         ],
+        server: serverEntry && standalone ? { path: serverEntry.entryPath } : undefined,
     });
     const fallback = fallbackCount > 0 ? 'true' : 'false';
     const warnings = warningsCount > 0 ? 'true' : 'false';
@@ -160,8 +166,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
 // `condition` because the directories might be created by the build command
 // or plugins.
 const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC }, featureFlags, packagePath, returnValues, }) {
-    if (featureFlags?.netlify_build_server_entry &&
-        (await pathExists(resolve(buildDir, packagePath || '', 'netlify/server')))) {
+    if (useServer(featureFlags) && (await pathExists(resolve(buildDir, packagePath || '', 'netlify/server')))) {
         return true;
     }
     const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== '';
@@ -210,6 +215,9 @@ export const bundleFunctions = {
 // `zip-it-and-ship-it` methods. Therefore, we need to use an intermediary
 // function and export them so tests can use it.
 export const zipItAndShipIt = {
+    async bundle(options) {
+        return await bundle(options);
+    },
     async zipFunctions(...args) {
         return await zipFunctions(...args);
     },

package/lib/plugins_core/functions/server_entry.d.ts

@@ -1,8 +1,8 @@
 import { type FeatureFlags } from '../../core/feature_flags.js';
-export declare const SERVER_ENTRY_FUNCTION_NAME = "___netlify-server";
+export declare const useServer: (featureFlags?: FeatureFlags) => boolean;
 export interface ServerEntry {
     entryPath: string;
-    shimPath: string;
+    packageRoot: string;
     relativeEntryPath: string;
 }
 export declare const getServerEntry: ({ buildDir, packagePath, featureFlags, }: {
@@ -10,3 +10,8 @@ export declare const getServerEntry: ({ buildDir, packagePath, featureFlags, }:
     packagePath?: string;
     featureFlags?: FeatureFlags;
 }) => Promise<ServerEntry | undefined>;
+/**
+ * Writes the file a server is bundled from when it travels as a function, and
+ * returns its path.
+ */
+export declare const writeServerShim: ({ entryPath, packageRoot }: ServerEntry) => Promise<string>;

package/lib/plugins_core/functions/server_entry.js

@@ -2,14 +2,12 @@ import { mkdir, readdir, writeFile } from 'fs/promises';
 import { join, resolve } from 'path';
 import { pathExists } from '../../utils/path_exists.js';
 import { addErrorInfo } from '../../error/info.js';
-export const SERVER_ENTRY_FUNCTION_NAME = '___netlify-server';
 const SERVER_ENTRY_DIR = 'netlify/server';
 const SERVER_ENTRY_BASENAMES = new Set(['index.js', 'index.mjs', 'index.ts', 'index.mts']);
-const SERVER_SHIM_DIR = '.netlify/server-entry';
-// Finds the user's server entrypoint and materializes the function entry it is
-// deployed as.
+export const useServer = (featureFlags) => featureFlags?.netlify_build_server_entry === true || featureFlags?.netlify_build_server_standalone === true;
+// Finds the user's server entrypoint.
 export const getServerEntry = async ({ buildDir, packagePath, featureFlags, }) => {
-    if (!featureFlags?.netlify_build_server_entry) {
+    if (!useServer(featureFlags)) {
         return undefined;
     }
     const packageRoot = resolve(buildDir, packagePath ?? '');
@@ -26,19 +24,19 @@ export const getServerEntry = async ({ buildDir, packagePath, featureFlags, }) =
         addErrorInfo(error, { type: 'resolveConfig' });
         throw error;
     }
-    const entryPath = join(serverDir, candidates[0]);
-    const shimDir = join(packageRoot, SERVER_SHIM_DIR);
-    const shimPath = join(shimDir, `${SERVER_ENTRY_FUNCTION_NAME}.mjs`);
-    await mkdir(shimDir, { recursive: true });
-    await writeFile(shimPath, getShimContents(entryPath));
     return {
-        entryPath,
-        shimPath,
+        entryPath: join(serverDir, candidates[0]),
+        packageRoot,
         relativeEntryPath: `${SERVER_ENTRY_DIR}/${candidates[0]}`,
     };
 };
-// The shim gives the server the deploy surface of a function without touching
-// the user's code.
+// Everything below carries a server through the functions plumbing, which is
+// how it was deployed before it stood on its own. It goes away once no deploy
+// is built with the function channel on.
+const SERVER_FUNCTION_NAME = '___netlify-server';
+const SERVER_SHIM_DIR = '.netlify/server-entry';
+// Gives the server the deploy surface of a function without touching the user's
+// code, so that it can be bundled and uploaded as one.
 const getShimContents = (entryPath) => `import * as server from ${JSON.stringify(entryPath)}
 
 export default server.default ?? server
@@ -51,3 +49,14 @@ export const config = {
   preferStatic: true,
 }
 `;
+/**
+ * Writes the file a server is bundled from when it travels as a function, and
+ * returns its path.
+ */
+export const writeServerShim = async ({ entryPath, packageRoot }) => {
+    const shimDir = join(packageRoot, SERVER_SHIM_DIR);
+    await mkdir(shimDir, { recursive: true });
+    const shimPath = join(shimDir, `${SERVER_FUNCTION_NAME}.mjs`);
+    await writeFile(shimPath, getShimContents(entryPath));
+    return shimPath;
+};

package/lib/plugins_core/functions/zisi.d.ts

@@ -1,4 +1,4 @@
-import { type FunctionConfig, type ZipFunctionsOptions } from '@netlify/zip-it-and-ship-it';
+import { type BundleOptions, type FunctionConfig, type MixedPaths, type ServerOptions } from '@netlify/zip-it-and-ship-it';
 import type { FeatureFlags } from '../../core/feature_flags.js';
 type GetZisiParametersType = {
     branch?: string;
@@ -11,9 +11,11 @@ type GetZisiParametersType = {
     isRunningLocally: boolean;
     repositoryRoot: string;
     userNodeVersion: string;
-    systemLog: ZipFunctionsOptions['systemLog'];
+    systemLog: BundleOptions['systemLog'];
+    paths: MixedPaths;
+    server?: ServerOptions;
 };
-export declare const getZisiParameters: ({ branch, buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, repositoryRoot, userNodeVersion, systemLog, }: GetZisiParametersType) => ZipFunctionsOptions;
+export declare const getZisiParameters: ({ branch, buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, paths, repositoryRoot, server, userNodeVersion, systemLog, }: GetZisiParametersType) => BundleOptions;
 export declare const normalizeFunctionConfig: ({ buildDir, functionConfig, isRunningLocally, nodeVersion, }: {
     buildDir: string;
     functionConfig: Record<string, any>;

package/lib/plugins_core/functions/zisi.js

@@ -16,7 +16,7 @@ const getLambdaNodeVersion = (childEnv, userNodeVersion) => {
     }
     return undefined;
 };
-export const getZisiParameters = ({ branch, buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, repositoryRoot, userNodeVersion, systemLog, }) => {
+export const getZisiParameters = ({ branch, buildDir, childEnv, featureFlags, functionsConfig, functionsDist, internalFunctionsSrc, isRunningLocally, paths, repositoryRoot, server, userNodeVersion, systemLog, }) => {
     const nodeVersion = getLambdaNodeVersion(childEnv, userNodeVersion);
     const manifest = join(functionsDist, 'manifest.json');
     const config = Object.fromEntries(Object.entries(functionsConfig).map(([expression, object]) => [
@@ -30,11 +30,16 @@ export const getZisiParameters = ({ branch, buildDir, childEnv, featureFlags, fu
     return {
         basePath: buildDir,
         branch,
-        config,
-        manifest,
+        destFolder: functionsDist,
         featureFlags: zisiFeatureFlags,
+        functions: {
+            config,
+            configFileDirectories,
+            paths,
+        },
+        manifest,
         repositoryRoot,
-        configFileDirectories,
+        server,
         systemLog,
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "36.4.8",
+  "version": "37.1.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -68,12 +68,12 @@
     "@netlify/cache-utils": "^7.1.2",
     "@netlify/config": "^25.2.5",
     "@netlify/edge-bundler": "16.0.4",
-    "@netlify/functions-utils": "^7.1.9",
+    "@netlify/functions-utils": "^7.1.11",
     "@netlify/git-utils": "^7.1.1",
-    "@netlify/opentelemetry-utils": "^3.1.0",
+    "@netlify/opentelemetry-utils": "^4.0.0",
     "@netlify/plugins-list": "^6.81.6",
     "@netlify/run-utils": "^7.1.0",
-    "@netlify/zip-it-and-ship-it": "15.5.1",
+    "@netlify/zip-it-and-ship-it": "16.1.0",
     "@sindresorhus/slugify": "^2.0.0",
     "ansis": "^4.1.0",
     "execa": "^8.0.0",
@@ -108,8 +108,8 @@
   },
   "devDependencies": {
     "@netlify/nock-udp": "^6.1.0",
-    "@opentelemetry/api": "~1.8.0",
-    "@opentelemetry/sdk-trace-base": "~1.24.0",
+    "@opentelemetry/api": "~1.9.0",
+    "@opentelemetry/sdk-trace-base": "~2.8.0",
     "@types/node": "^22.12.0",
     "@vitest/coverage-v8": "^3.2.6",
     "atob": "^2.1.2",
@@ -126,8 +126,8 @@
     "yarn": "^1.22.22"
   },
   "peerDependencies": {
-    "@netlify/opentelemetry-sdk-setup": "^2.0.0 || ^3.0.0",
-    "@opentelemetry/api": "~1.8.0"
+    "@netlify/opentelemetry-sdk-setup": "^3.0.0 || ^4.0.0",
+    "@opentelemetry/api": "~1.9.0"
   },
   "peerDependenciesMeta": {
     "@netlify/opentelemetry-sdk-setup": {
@@ -137,5 +137,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "ff2974e358a0d36f213a9a24e844cd0c3ca44c18"
+  "gitHead": "22902a5992a5909a97bb366c88c96f6d95c18b33"
 }