@netlify/zip-it-and-ship-it 16.5.1 → 16.6.0

package/dist/config.d.ts

@@ -9,6 +9,14 @@ export declare const serverSize: z.ZodPreprocess<z.ZodEnum<{
     medium: "medium";
     large: "large";
 }>>;
+export declare const isValidRange: ({ min, max }: {
+    min?: number;
+    max?: number;
+}) => boolean;
+export declare const serverScale: z.ZodObject<{
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
 export declare const functionConfigShape: z.ZodObject<{
     background: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
     externalNodeModules: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;

package/dist/config.js

@@ -41,6 +41,18 @@ const SERVER_REGION_CODES = ['cmh', 'fra'];
 export const serverRegion = z.preprocess((input) => (typeof input === 'string' ? input.toLowerCase() : input), z.enum(SERVER_REGION_CODES));
 const SERVER_SIZES = ['small', 'medium', 'large'];
 export const serverSize = z.preprocess((input) => (typeof input === 'string' ? input.toLowerCase() : input), z.enum(SERVER_SIZES));
+const integerAtLeast = (min) => {
+    const message = `Must be an integer greater than or equal to ${String(min)}`;
+    return z.number({ message }).int({ message }).min(min, { message }).optional();
+};
+export const isValidRange = ({ min, max }) => min === undefined || max === undefined || min <= max;
+export const serverScale = z
+    .object({
+    min: integerAtLeast(0),
+    max: integerAtLeast(1),
+})
+    .strict()
+    .refine(isValidRange, { message: "'min' cannot be greater than 'max'" });
 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));

package/dist/main.d.ts

@@ -6,7 +6,7 @@ import { RuntimeName } from './runtimes/runtime.js';
 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 { NetlifyServerConfig, ServerOptions, ServerResult, ZipServerOptions } from './zip.js';
+export type { NetlifyServerConfig, ServerOptions, ServerResult, ServerScale, ZipServerOptions } from './zip.js';
 export { findServerEntry, getServerRoutes } from './server.js';
 export type { FunctionsBag, MixedPaths } from './paths.js';
 export { ArchiveFormat, ARCHIVE_FORMAT } from './archive.js';

package/dist/manifest.d.ts

@@ -1,6 +1,6 @@
 import type { InvocationMode } from './function.js';
 import type { TrafficRules } from './rate_limit.js';
-import type { ServerResult } from './server.js';
+import type { ServerResult, ServerScale } from './server.js';
 import type { FunctionResult } from './utils/format_result.js';
 import type { ExtendedRoute, Route } from './utils/routes.js';
 interface ManifestFunction {
@@ -35,6 +35,7 @@ interface ManifestServer {
     routes?: ExtendedRoute[];
     runtime: string;
     runtimeVersion?: string;
+    scale?: ServerScale;
 }
 interface ManifestBase {
     system: {

package/dist/manifest.js

@@ -21,7 +21,7 @@ export const createServerManifest = async ({ path, server }) => {
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
-const formatServerForManifest = ({ bundler, excludedRoutes, instanceSize, mainFile, path, region, routes, runtime, runtimeVersion, }) => {
+const formatServerForManifest = ({ bundler, excludedRoutes, instanceSize, mainFile, path, region, routes, runtime, runtimeVersion, scale, }) => {
     const server = {
         bundler,
         instanceSize,
@@ -30,6 +30,7 @@ const formatServerForManifest = ({ bundler, excludedRoutes, instanceSize, mainFi
         region,
         runtime,
         runtimeVersion,
+        scale,
     };
     if (routes?.length) {
         server.routes = routes;

package/dist/runtimes/node/in_source_config/index.d.ts

@@ -100,6 +100,10 @@ export declare const serverConfig: z.ZodObject<{
         cmh: "cmh";
         fra: "fra";
     }>>>;
+    scale: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
     size: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
         small: "small";
         medium: "medium";

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, serverRegion, serverSize, withComputeResources } from '../../../config.js';
+import { functionConfigShape, serverRegion, serverScale, serverSize, withComputeResources, } from '../../../config.js';
 import { INVOCATION_MODE } from '../../../function.js';
 import { rateLimit } from '../../../rate_limit.js';
 import { ensureArray } from '../../../utils/ensure_array.js';
@@ -62,6 +62,7 @@ export const serverConfig = z
     includedFiles: z.array(z.string()).optional(),
     path: paths,
     region: serverRegion.optional(),
+    scale: serverScale.optional(),
     size: serverSize.optional(),
 })
     .strict();
@@ -186,7 +187,9 @@ const parseServerConfig = (config, functionName) => {
     }
     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 does not support the ${issue.keys
+            .map((key) => `'${[...issue.path, key].join('.')}'`)
+            .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 });
 };

package/dist/server.d.ts

@@ -8,6 +8,13 @@ import type { ExtendedRoute, Route } from './utils/routes.js';
  * none.
  */
 export declare const findServerEntry: (directory: string) => Promise<string | undefined>;
+/**
+ * How many instances the server runs.
+ */
+export type ServerScale = {
+    min?: number;
+    max?: number;
+};
 /**
  * Server configuration from the `[server]` block of the Netlify configuration
  * file. The server's in-source configuration takes precedence over it.
@@ -17,6 +24,7 @@ export interface NetlifyServerConfig {
     includedFiles?: string[];
     path?: string | string[];
     region?: string;
+    scale?: ServerScale;
     size?: string;
 }
 /**
@@ -36,6 +44,7 @@ export type ServerResult = {
     routes?: ExtendedRoute[];
     runtime: RuntimeName;
     runtimeVersion?: string;
+    scale?: ServerScale;
     size?: number;
 };
 /**

package/dist/server.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
 import { extname, join, resolve } from 'path';
 import { ARCHIVE_FORMAT } from './archive.js';
+import { isValidRange } from './config.js';
 import { getFunctionFromPath } from './runtimes/index.js';
 import { parseFile, serverConfig } from './runtimes/node/in_source_config/index.js';
 import { RUNTIME } from './runtimes/runtime.js';
@@ -50,10 +51,25 @@ const parseNetlifyServerConfig = (config = {}) => {
     const location = issue.path.length === 0 ? '' : ` on '${issue.path.join('.')}'`;
     throw new FunctionBundlingUserError(`Netlify Server has a configuration error in the [server] block${location}: ${issue.message}`, { functionName: SERVER_NAME, runtime: RUNTIME.JAVASCRIPT });
 };
+// `min` and `max` are merged separately, so each source can set one of them.
+const mergeServerScale = (inSource = {}, fromNetlifyConfig = {}) => {
+    const scale = removeUndefined({
+        min: inSource.min ?? fromNetlifyConfig.min,
+        max: inSource.max ?? fromNetlifyConfig.max,
+    });
+    if (scale.min === undefined && scale.max === undefined) {
+        return undefined;
+    }
+    if (!isValidRange(scale)) {
+        throw new FunctionBundlingUserError(`Netlify Server has a configuration error on 'scale': 'min' (${String(scale.min)}) cannot be greater than 'max' (${String(scale.max)}) once the in-source configuration and the [server] block are combined`, { functionName: SERVER_NAME, runtime: RUNTIME.JAVASCRIPT });
+    }
+    return scale;
+};
 const mergeServerConfig = (inSource, fromNetlifyConfig) => ({
     excludedPath: inSource.excludedPath ?? fromNetlifyConfig.excludedPath,
     path: inSource.path ?? fromNetlifyConfig.path,
     region: inSource.region ?? fromNetlifyConfig.region,
+    scale: mergeServerScale(inSource.scale, fromNetlifyConfig.scale),
     size: inSource.size ?? fromNetlifyConfig.size,
 });
 /**
@@ -137,6 +153,7 @@ export const bundleServer = async (server, destFolder, { basePath, cache, featur
         routes: toServerRoutes(config.path),
         runtime: result.runtime,
         runtimeVersion: result.runtimeVersion,
+        scale: config.scale,
         size: result.size,
     });
 };

package/dist/zip.d.ts

@@ -1,7 +1,7 @@
 import { ArchiveFormat } from './archive.js';
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
-import { type NetlifyServerConfig, type ServerOptions, type ServerResult } from './server.js';
+import { type NetlifyServerConfig, type ServerOptions, type ServerResult, type ServerScale } from './server.js';
 import { type MixedPaths } from './paths.js';
 import { FunctionResult } from './utils/format_result.js';
 import { LogFunction } from './utils/logger.js';
@@ -38,7 +38,7 @@ export interface ZipServerOptions {
     repositoryRoot?: string;
     systemLog?: LogFunction;
 }
-export type { NetlifyServerConfig, ServerOptions, ServerResult };
+export type { NetlifyServerConfig, ServerOptions, ServerResult, ServerScale };
 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, config, 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

@@ -5,7 +5,7 @@ import pMap from 'p-map';
 import { ARCHIVE_FORMAT } from './archive.js';
 import { getFlags } from './feature_flags.js';
 import { createFunctionsManifest, createServerManifest } from './manifest.js';
-import { bundleServer } from './server.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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "16.5.1",
+  "version": "16.6.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -99,5 +99,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "33d74df3817de0bc8b237e82f2d7b10b4983c93c"
+  "gitHead": "a2dde99b2116c8dbea79e4ca18886d1466577a1c"
 }