@netlify/zip-it-and-ship-it 16.3.1 → 16.4.0

package/dist/config.d.ts

@@ -1,8 +1,13 @@
 import { z } from 'zod';
 import { FunctionSource } from './function.js';
 export declare const serverRegion: z.ZodPreprocess<z.ZodEnum<{
+    cmh: "cmh";
     fra: "fra";
-    iad: "iad";
+}>>;
+export declare const serverSize: z.ZodPreprocess<z.ZodEnum<{
+    small: "small";
+    medium: "medium";
+    large: "large";
 }>>;
 export declare const functionConfigShape: z.ZodObject<{
     background: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;

package/dist/config.js

@@ -37,14 +37,10 @@ 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);
+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 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 { ServerOptions, ServerResult, ZipServerOptions } from './zip.js';
+export type { NetlifyServerConfig, ServerOptions, ServerResult, 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

@@ -28,14 +28,13 @@ interface ManifestFunction {
 interface ManifestServer {
     bundler?: string;
     excludedRoutes?: Route[];
+    instanceSize?: string;
     mainFile: string;
-    memory?: number;
     path: string;
     region?: string;
     routes?: ExtendedRoute[];
     runtime: string;
     runtimeVersion?: string;
-    vcpu?: number;
 }
 interface ManifestBase {
     system: {

package/dist/manifest.js

@@ -21,16 +21,15 @@ export const createServerManifest = async ({ path, server }) => {
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
-const formatServerForManifest = ({ bundler, excludedRoutes, mainFile, memory, path, region, routes, runtime, runtimeVersion, vcpu, }) => {
+const formatServerForManifest = ({ bundler, excludedRoutes, instanceSize, mainFile, path, region, routes, runtime, runtimeVersion, }) => {
     const server = {
         bundler,
+        instanceSize,
         mainFile,
-        memory,
         path: resolve(path),
         region,
         runtime,
         runtimeVersion,
-        vcpu,
     };
     if (routes?.length) {
         server.routes = routes;

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

@@ -92,14 +92,35 @@ export declare const inSourceConfig: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type InSourceConfig = z.infer<typeof inSourceConfig>;
+export declare const serverConfig: z.ZodObject<{
+    excludedPath: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+    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<{
+        cmh: "cmh";
+        fra: "fra";
+    }>>>;
+    size: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>>>;
+}, z.core.$strict>;
+export type ServerConfig = z.infer<typeof serverConfig>;
 export declare const serverInSourceConfig: z.ZodObject<{
-    includedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludedPath: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
     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<{
+        cmh: "cmh";
         fra: "fra";
-        iad: "iad";
     }>>>;
+    size: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>>>;
+    includedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
+export type ServerInSourceConfig = z.infer<typeof serverInSourceConfig>;
 /**
  * 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.

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, withComputeResources } from '../../../config.js';
+import { functionConfigShape, serverRegion, serverSize, withComputeResources } from '../../../config.js';
 import { INVOCATION_MODE } from '../../../function.js';
 import { rateLimit } from '../../../rate_limit.js';
 import { ensureArray } from '../../../utils/ensure_array.js';
@@ -56,11 +56,17 @@ export const inSourceConfig = functionConfigShape
     message: '`memory` and `vcpu` cannot both be set.',
     path: ['vcpu'],
 });
-export const serverInSourceConfig = z
+export const serverConfig = z
     .object({
-    includedFiles: z.array(z.string()).optional(),
+    excludedPath: paths,
     path: paths,
     region: serverRegion.optional(),
+    size: serverSize.optional(),
+})
+    .strict();
+export const serverInSourceConfig = serverConfig
+    .extend({
+    includedFiles: z.array(z.string()).optional(),
 })
     .strict();
 /**

package/dist/server.d.ts

@@ -8,28 +8,43 @@ import type { ExtendedRoute, Route } from './utils/routes.js';
  * none.
  */
 export declare const findServerEntry: (directory: string) => Promise<string | undefined>;
+/**
+ * Server configuration from the `[server]` block of the Netlify configuration
+ * file. The server's in-source configuration takes precedence over it.
+ */
+export interface NetlifyServerConfig {
+    excludedPath?: string | string[];
+    path?: string | string[];
+    region?: string;
+    size?: string;
+}
 /**
  * Returns the routes the server at `entryPath` claims, read from its in-source
- * configuration, without bundling it.
+ * configuration and the `config` given, without bundling it.
  */
-export declare const getServerRoutes: (entryPath: string) => Promise<ExtendedRoute[]>;
+export declare const getServerRoutes: (entryPath: string, { config }?: {
+    config?: NetlifyServerConfig;
+}) => Promise<ExtendedRoute[]>;
 export type ServerResult = {
     bundler?: string;
     excludedRoutes?: Route[];
+    instanceSize?: string;
     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 {
+    /**
+     * Server configuration from the Netlify configuration file.
+     */
+    config?: NetlifyServerConfig;
     /**
      * Path of the user's server entry file.
      */

package/dist/server.js

@@ -2,7 +2,7 @@ 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 { parseFile, serverConfig, } 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';
@@ -40,13 +40,30 @@ export const findServerEntry = async (directory) => {
 };
 // A server always sets `preferStatic: true`.
 const toServerRoutes = (paths = DEFAULT_SERVER_PATHS) => getRoutes(SERVER_NAME, paths).map((route) => ({ ...route, prefer_static: true }));
+const toExcludedServerRoutes = (paths = []) => paths.length === 0 ? undefined : getRoutes(SERVER_NAME, paths);
+const parseNetlifyServerConfig = (config = {}) => {
+    const { data, error, success } = serverConfig.safeParse(config);
+    if (success) {
+        return data;
+    }
+    const [issue] = error.issues;
+    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 });
+};
+const mergeServerConfig = (inSource, fromNetlifyConfig) => ({
+    excludedPath: inSource.excludedPath ?? fromNetlifyConfig.excludedPath,
+    path: inSource.path ?? fromNetlifyConfig.path,
+    region: inSource.region ?? fromNetlifyConfig.region,
+    size: inSource.size ?? fromNetlifyConfig.size,
+});
 /**
  * Returns the routes the server at `entryPath` claims, read from its in-source
- * configuration, without bundling it.
+ * configuration and the `config` given, without bundling it.
  */
-export const getServerRoutes = async (entryPath) => {
-    const { config } = await parseFile(resolve(entryPath), { functionName: SERVER_NAME, isServer: true });
-    return toServerRoutes(config.path);
+export const getServerRoutes = async (entryPath, { config } = {}) => {
+    const fromNetlifyConfig = parseNetlifyServerConfig(config);
+    const { config: inSource } = await parseFile(resolve(entryPath), { functionName: SERVER_NAME, isServer: true });
+    return toServerRoutes(mergeServerConfig(inSource, fromNetlifyConfig).path);
 };
 const readServerSource = async (srcPath, { cache, featureFlags }) => {
     let source;
@@ -68,6 +85,7 @@ const readServerSource = async (srcPath, { cache, featureFlags }) => {
     return source;
 };
 export const bundleServer = async (server, destFolder, { basePath, cache, featureFlags, logger, repositoryRoot, }) => {
+    const fromNetlifyConfig = parseNetlifyServerConfig(server.config);
     const srcPath = resolve(server.path);
     const source = await readServerSource(srcPath, { cache, featureFlags });
     const zipResult = await source.runtime.zipFunction({
@@ -99,17 +117,18 @@ export const bundleServer = async (server, destFolder, { basePath, cache, featur
         path,
         runtime: source.runtime,
     });
+    const inSource = (zipResult.staticAnalysisResult?.config ?? {});
+    const config = mergeServerConfig(inSource, fromNetlifyConfig);
     return removeUndefined({
         bundler: result.bundler,
-        excludedRoutes: result.excludedRoutes,
+        excludedRoutes: toExcludedServerRoutes(config.excludedPath),
+        instanceSize: config.size,
         mainFile: result.mainFile,
-        memory: result.memory,
         path: result.path,
-        region: result.region,
-        routes: toServerRoutes(zipResult.staticAnalysisResult?.config.path),
+        region: config.region,
+        routes: toServerRoutes(config.path),
         runtime: result.runtime,
         runtimeVersion: result.runtimeVersion,
         size: result.size,
-        vcpu: result.vcpu,
     });
 };

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 ServerOptions, type ServerResult } from './server.js';
+import { type NetlifyServerConfig, 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';
@@ -24,6 +24,11 @@ export type ZipFunctionsOptions = ZipFunctionOptions & {
 };
 export interface ZipServerOptions {
     basePath?: string;
+    /**
+     * Server configuration from the `[server]` block of the Netlify
+     * configuration file.
+     */
+    config?: NetlifyServerConfig;
     debug?: boolean;
     featureFlags?: FeatureFlags;
     /**
@@ -33,7 +38,7 @@ export interface ZipServerOptions {
     repositoryRoot?: string;
     systemLog?: LogFunction;
 }
-export type { ServerOptions, ServerResult };
+export type { NetlifyServerConfig, 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 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

@@ -81,12 +81,12 @@ export const zipFunctions = async function (input, destFolder, { archiveFormat =
     });
     return formattedResults;
 };
-export const zipServer = async function (srcPath, destFolder, { basePath, debug, featureFlags: inputFeatureFlags, manifest, repositoryRoot = basePath, systemLog, } = {}) {
+export const zipServer = async function (srcPath, destFolder, { basePath, config, 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, {
+    const result = await bundleServer({ config, path: srcPath }, destFolder, {
         basePath,
         cache,
         featureFlags,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "16.3.1",
+  "version": "16.4.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -99,5 +99,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "288d53ba807d13535afdb605f49034e0a9a4082e"
+  "gitHead": "19447a3826a8d26af1bcdc704754e8a8586597f1"
 }