@netlify/zip-it-and-ship-it 16.2.2 → 16.3.0

package/dist/config.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import { FunctionSource } from './function.js';
+export declare const serverRegion: z.ZodPreprocess<z.ZodEnum<{
+    fra: "fra";
+    iad: "iad";
+}>>;
 export declare const functionConfigShape: z.ZodObject<{
     background: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
@@ -51,4 +55,5 @@ declare const getConfigForFunction: ({ config, configFileDirectories, func, }: {
     configFileDirectories?: string[];
     func: FunctionWithoutConfig;
 }) => Promise<FunctionConfig>;
+export declare const withComputeResources: <T extends FunctionConfig>(merged: T, sources: Pick<FunctionConfig, "memory" | "vcpu">[]) => T;
 export { Config, FunctionConfig, FunctionWithoutConfig, getConfigForFunction };

package/dist/config.js

@@ -37,6 +37,14 @@ const FUNCTION_REGION_CODES = Object.keys(FUNCTION_REGION_KEYS);
 // Accept any casing in source (`iad`, `IAD`, `Iad`) but normalize to lower
 // case before validating and writing to the manifest.
 const functionRegion = z.preprocess((input) => (typeof input === 'string' ? input.toLowerCase() : input), z.enum(FUNCTION_REGION_CODES));
+// Checked against `ServerRegion` the same way `FUNCTION_REGION_KEYS` is
+// against `FunctionRegion`.
+const SERVER_REGION_KEYS = {
+    fra: null,
+    iad: null,
+};
+const SERVER_REGION_CODES = Object.keys(SERVER_REGION_KEYS);
+export const serverRegion = z.preprocess((input) => (typeof input === 'string' ? input.toLowerCase() : input), z.enum(SERVER_REGION_CODES));
 const FUNCTION_MEMORY_MIN_MB = 1024;
 const FUNCTION_MEMORY_MAX_MB = 4096;
 const functionMemory = z.preprocess((input) => (typeof input === 'string' || typeof input === 'number' ? parseMemoryMB(input) : input), z.number().int().min(FUNCTION_MEMORY_MIN_MB).max(FUNCTION_MEMORY_MAX_MB));
@@ -75,10 +83,10 @@ const getConfigForFunction = async ({ config, configFileDirectories, func, }) =>
         return fromConfig;
     }
     const fromFile = await getFromFile(func);
-    return {
+    return withComputeResources({
         ...fromConfig,
         ...fromFile,
-    };
+    }, [fromConfig, fromFile]);
 };
 const getFromMainConfig = ({ config, func, }) => {
     if (!config) {
@@ -101,7 +109,29 @@ const getFromMainConfig = ({ config, func, }) => {
     })
         .sort(({ weight: weightA }, { weight: weightB }) => weightA - weightB)
         .map(({ expression }) => config[expression]);
-    return mergeOptions.apply({ concatArrays: true, ignoreUndefined: true }, matches);
+    const merged = withComputeResources(mergeOptions.apply({ concatArrays: true, ignoreUndefined: true }, matches), matches);
+    const memory = merged.memory;
+    if (typeof memory === 'string') {
+        merged.memory = parseMemoryMB(memory);
+    }
+    return merged;
+};
+// memory and vcpu are two mutually exclusive ways of sizing a function, so
+// they can't be merged key by key like other properties
+// a wildcard block with memory and a more specific block with vcpu
+// would otherwise produce both. Instead, the highest-priority source that
+// sets either of them supplies the pair.
+export const withComputeResources = (merged, sources) => {
+    const winner = [...sources].reverse().find((source) => source.memory !== undefined || source.vcpu !== undefined);
+    if (winner === undefined) {
+        return merged;
+    }
+    const { memory, vcpu, ...rest } = merged;
+    return {
+        ...rest,
+        ...(winner.memory === undefined ? {} : { memory: winner.memory }),
+        ...(winner.vcpu === undefined ? {} : { vcpu: winner.vcpu }),
+    };
 };
 const getFromFile = async (func) => {
     const filename = `${basename(func.mainFile, extname(func.mainFile))}.json`;

package/dist/main.d.ts

@@ -7,7 +7,7 @@ import type { ExtendedRoute, Route } from './utils/routes.js';
 export { Config, FunctionConfig } from './config.js';
 export { zipFunction, zipFunctions, zipServer, ZipFunctionOptions, ZipFunctionsOptions } from './zip.js';
 export type { ServerOptions, ServerResult, ZipServerOptions } from './zip.js';
-export { findServerEntry } from './server.js';
+export { findServerEntry, getServerRoutes } from './server.js';
 export type { FunctionsBag, MixedPaths } from './paths.js';
 export { ArchiveFormat, ARCHIVE_FORMAT } from './archive.js';
 export type { TrafficRules } from './rate_limit.js';

package/dist/main.js

@@ -7,7 +7,7 @@ import { RUNTIME } from './runtimes/runtime.js';
 import { RuntimeCache } from './utils/cache.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
 export { zipFunction, zipFunctions, zipServer } from './zip.js';
-export { findServerEntry } from './server.js';
+export { findServerEntry, getServerRoutes } 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/runtimes/node/in_source_config/index.d.ts

@@ -16,6 +16,7 @@ export interface StaticAnalysisResult {
 }
 interface FindISCDeclarationsOptions {
     functionName: string;
+    isServer?: boolean;
 }
 export declare const inSourceConfig: z.ZodObject<{
     name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
@@ -91,17 +92,25 @@ export declare const inSourceConfig: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type InSourceConfig = z.infer<typeof inSourceConfig>;
+export declare const serverInSourceConfig: z.ZodObject<{
+    includedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    path: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+    region: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        fra: "fra";
+        iad: "iad";
+    }>>>;
+}, z.core.$strict>;
 /**
  * Loads a file at a given path, parses it into an AST, and returns a series of
  * data points, such as in-source configuration properties and other metadata.
  */
-export declare const parseFile: (sourcePath: string, { functionName }: FindISCDeclarationsOptions) => Promise<StaticAnalysisResult>;
+export declare const parseFile: (sourcePath: string, { functionName, isServer }: FindISCDeclarationsOptions) => Promise<StaticAnalysisResult>;
 /**
  * Takes a JS/TS source as a string, parses it into an AST, and returns a
  * series of data points, such as in-source configuration properties and
  * other metadata.
  */
-export declare const parseSource: (source: string, { functionName }: FindISCDeclarationsOptions) => StaticAnalysisResult;
+export declare const parseSource: (source: string, { functionName, isServer }: FindISCDeclarationsOptions) => StaticAnalysisResult;
 export declare const augmentFunctionConfig: (mainFile: string, tomlConfig: FunctionConfig, inSourceConfig?: InSourceConfig) => {
     background?: boolean | undefined;
     externalNodeModules?: string[] | undefined;

package/dist/runtimes/node/in_source_config/index.js

@@ -3,7 +3,7 @@ import { dirname } from 'path';
 // this dependency.
 import mergeOptions from 'merge-options';
 import { z } from 'zod';
-import { functionConfigShape } from '../../../config.js';
+import { functionConfigShape, serverRegion, withComputeResources } from '../../../config.js';
 import { INVOCATION_MODE } from '../../../function.js';
 import { rateLimit } from '../../../rate_limit.js';
 import { ensureArray } from '../../../utils/ensure_array.js';
@@ -20,6 +20,10 @@ export const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
 const httpMethod = z.enum(['GET', 'POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE', 'HEAD']);
 const httpMethods = z.preprocess((input) => (typeof input === 'string' ? input.toUpperCase() : input), httpMethod);
 const path = z.string().startsWith('/', { message: "Must start with a '/'" });
+const paths = z
+    .union([path, z.array(path)], { error: () => ({ message: 'Must be a string or array of strings' }) })
+    .transform(ensureArray)
+    .optional();
 export const inSourceConfig = functionConfigShape
     .pick({
     background: true,
@@ -43,14 +47,8 @@ export const inSourceConfig = functionConfigShape
     })
         .transform(ensureArray)
         .optional(),
-    path: z
-        .union([path, z.array(path)], { error: () => ({ message: 'Must be a string or array of strings' }) })
-        .transform(ensureArray)
-        .optional(),
-    excludedPath: z
-        .union([path, z.array(path)], { error: () => ({ message: 'Must be a string or array of strings' }) })
-        .transform(ensureArray)
-        .optional(),
+    path: paths,
+    excludedPath: paths,
     preferStatic: z.boolean().optional().catch(undefined),
     rateLimit: rateLimit.optional().catch(undefined),
 })
@@ -58,6 +56,13 @@ export const inSourceConfig = functionConfigShape
     message: '`memory` and `vcpu` cannot both be set.',
     path: ['vcpu'],
 });
+export const serverInSourceConfig = z
+    .object({
+    includedFiles: z.array(z.string()).optional(),
+    path: paths,
+    region: serverRegion.optional(),
+})
+    .strict();
 /**
  * Resolves the default export expression to an ObjectExpression if possible,
  * following identifier bindings when needed.
@@ -148,21 +153,47 @@ const validateScheduleFunction = (functionFound, scheduleFound, functionName) =>
  * Loads a file at a given path, parses it into an AST, and returns a series of
  * data points, such as in-source configuration properties and other metadata.
  */
-export const parseFile = async (sourcePath, { functionName }) => {
+export const parseFile = async (sourcePath, { functionName, isServer }) => {
     const source = await safelyReadSource(sourcePath);
     if (source === null) {
         return {
             config: {},
         };
     }
-    return parseSource(source, { functionName });
+    return parseSource(source, { functionName, isServer });
+};
+// Reads a named `config` export wrapped in `as const` or `satisfies`, which the
+// shared export traversal doesn't unwrap.
+const getWrappedConfigExport = (nodes, getAllBindings) => {
+    for (const node of nodes) {
+        if (node.type !== 'ExportNamedDeclaration' || node.declaration?.type !== 'VariableDeclaration') {
+            continue;
+        }
+        for (const declarator of node.declaration.declarations) {
+            if (declarator.id.type === 'Identifier' && declarator.id.name === 'config') {
+                const object = resolveObjectExpression(declarator.init ?? undefined, getAllBindings);
+                return object ? parseObject(object) : undefined;
+            }
+        }
+    }
+};
+const parseServerConfig = (config, functionName) => {
+    const { data, error, success } = serverInSourceConfig.safeParse(config);
+    if (success) {
+        return data;
+    }
+    const [issue] = error.issues;
+    const message = issue.code === 'unrecognized_keys'
+        ? `Netlify Server does not support the ${issue.keys.map((key) => `'${key}'`).join(', ')} configuration ${issue.keys.length === 1 ? 'property' : 'properties'}`
+        : `Netlify Server has a configuration error on '${issue.path.join('.')}': ${issue.message}`;
+    throw new FunctionBundlingUserError(message, { functionName, runtime: RUNTIME.JAVASCRIPT });
 };
 /**
  * Takes a JS/TS source as a string, parses it into an AST, and returns a
  * series of data points, such as in-source configuration properties and
  * other metadata.
  */
-export const parseSource = (source, { functionName }) => {
+export const parseSource = (source, { functionName, isServer }) => {
     const ast = safelyParseSource(source);
     if (ast === null) {
         return {
@@ -175,6 +206,17 @@ export const parseSource = (source, { functionName }) => {
     let scheduleFound = false;
     const getAllBindings = createBindingsMethod(ast.body);
     const { configExport, handlerExports, hasDefaultExport, defaultExportExpression, inputModuleFormat } = traverseNodes(ast.body, getAllBindings);
+    if (isServer) {
+        const config = configExport ??
+            getWrappedConfigExport(ast.body, getAllBindings) ??
+            getConfigFromDefaultExport(defaultExportExpression, getAllBindings) ??
+            {};
+        return {
+            config: parseServerConfig(config, functionName),
+            inputModuleFormat,
+            runtimeAPIVersion: 2,
+        };
+    }
     const isV2API = handlerExports.length === 0 && hasDefaultExport;
     if (isV2API) {
         const result = {
@@ -257,7 +299,7 @@ export const parseSource = (source, { functionName }) => {
     return result;
 };
 export const augmentFunctionConfig = (mainFile, tomlConfig, inSourceConfig = {}) => {
-    const mergedConfig = mergeOptions.call({ concatArrays: true }, tomlConfig, inSourceConfig);
+    const mergedConfig = withComputeResources(mergeOptions.call({ concatArrays: true }, tomlConfig, inSourceConfig), [tomlConfig, inSourceConfig]);
     // We can't simply merge included files from the TOML and from in-source
     // configuration because their globs are relative to different base paths.
     // In the future, we could shift things around so we resolve each glob

package/dist/runtimes/node/index.js

@@ -51,7 +51,7 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
         basePath = dirname(pluginsModulesPath);
         pluginsModulesPath = undefined;
     }
-    const staticAnalysisResult = await parseFile(mainFile, { functionName: name });
+    const staticAnalysisResult = await parseFile(mainFile, { functionName: name, isServer });
     const runtimeAPIVersion = isServer === true || staticAnalysisResult.runtimeAPIVersion === 2 ? 2 : 1;
     const mergedConfig = augmentFunctionConfig(mainFile, config, staticAnalysisResult.config);
     const { name: bundlerName, reason: bundlerReason } = await getBundlerName({

package/dist/server.d.ts

@@ -8,6 +8,11 @@ import type { ExtendedRoute, Route } from './utils/routes.js';
  * none.
  */
 export declare const findServerEntry: (directory: string) => Promise<string | undefined>;
+/**
+ * Returns the routes the server at `entryPath` claims, read from its in-source
+ * configuration, without bundling it.
+ */
+export declare const getServerRoutes: (entryPath: string) => Promise<ExtendedRoute[]>;
 export type ServerResult = {
     bundler?: string;
     excludedRoutes?: Route[];

package/dist/server.js

@@ -2,13 +2,13 @@ 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 { parseFile } from './runtimes/node/in_source_config/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 = '/*';
+const DEFAULT_SERVER_PATHS = ['/*'];
 // 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';
@@ -38,6 +38,16 @@ export const findServerEntry = async (directory) => {
     }
     return join(directory, candidates[0]);
 };
+// A server always sets `preferStatic: true`.
+const toServerRoutes = (paths = DEFAULT_SERVER_PATHS) => getRoutes(SERVER_NAME, paths).map((route) => ({ ...route, prefer_static: true }));
+/**
+ * Returns the routes the server at `entryPath` claims, read from its in-source
+ * configuration, without bundling it.
+ */
+export const getServerRoutes = async (entryPath) => {
+    const { config } = await parseFile(resolve(entryPath), { functionName: SERVER_NAME, isServer: true });
+    return toServerRoutes(config.path);
+};
 const readServerSource = async (srcPath, { cache, featureFlags }) => {
     let source;
     // A server that cannot be read is the user's file being wrong, so it is
@@ -96,7 +106,7 @@ export const bundleServer = async (server, destFolder, { basePath, cache, featur
         memory: result.memory,
         path: result.path,
         region: result.region,
-        routes: getRoutes(SERVER_NAME, SERVER_ROUTE).map((route) => ({ ...route, prefer_static: true })),
+        routes: toServerRoutes(zipResult.staticAnalysisResult?.config.path),
         runtime: result.runtime,
         runtimeVersion: result.runtimeVersion,
         size: result.size,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "16.2.2",
+  "version": "16.3.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -44,7 +44,7 @@
     "@babel/parser": "^7.22.5",
     "@babel/types": "^7.28.5",
     "@netlify/binary-info": "^1.0.0",
-    "@netlify/serverless-functions-api": "2.18.0",
+    "@netlify/serverless-functions-api": "2.24.0",
     "@opentelemetry/api": "~1.9.0",
     "@vercel/nft": "1.3.1",
     "archiver": "^8.0.0",
@@ -76,7 +76,7 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@netlify/types": "2.7.0",
+    "@netlify/types": "3.1.0",
     "@opentelemetry/sdk-trace-base": "~2.8.0",
     "@types/archiver": "8.0.0",
     "@types/node": "^22.12.0",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "9b3697b13c8c2294c30810b14a7ef9b8fd9e2bcd"
+  "gitHead": "56df60307c59031b2ab044446d634b10851459e3"
 }