@netlify/config 25.1.0 → 25.2.0

package/lib/edge_functions.d.ts

@@ -1,3 +1,5 @@
+export declare const EDGE_FUNCTIONS_PROPERTIES: string[];
+export declare const EDGE_FUNCTIONS_INTERNAL_PROPERTIES: string[];
 export declare const validations: ({
     example: () => {
         edge_functions: {

package/lib/edge_functions.js

@@ -4,10 +4,30 @@ const methodValues = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'];
 const isMethod = (value) => typeof value === 'string' && methodValues.includes(value.toUpperCase());
 const isValidHeaderValue = (value) => typeof value === 'boolean' || typeof value === 'string';
 const isValidHeaders = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && Object.values(value).every(isValidHeaderValue);
+// Properties that can be set on an edge function declaration from any origin,
+// including the user's `netlify.toml`.
+export const EDGE_FUNCTIONS_PROPERTIES = [
+    'path',
+    'excludedPath',
+    'pattern',
+    'excludedPattern',
+    'function',
+    'cache',
+    'method',
+    'header',
+    'name',
+];
+// Properties that can only be set by platform-generated configuration, i.e. by
+// frameworks and integrations through the Frameworks API — never from the
+// user's `netlify.toml`.
+export const EDGE_FUNCTIONS_INTERNAL_PROPERTIES = ['generator'];
 export const validations = [
     {
         property: 'edge_functions.*',
-        ...validProperties(['path', 'excludedPath', 'pattern', 'excludedPattern', 'function', 'cache', 'method', 'header'], []),
+        // This runs on the fully-merged configuration, which may include properties
+        // contributed by the Frameworks API, so it validates against the full set.
+        // User-facing restrictions are enforced separately (see `CONFIG_FILE_VALIDATIONS`).
+        ...validProperties([...EDGE_FUNCTIONS_PROPERTIES, ...EDGE_FUNCTIONS_INTERNAL_PROPERTIES], []),
         example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
     },
     {
@@ -68,6 +88,18 @@ export const validations = [
         message: 'must be a string.',
         example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
     },
+    {
+        property: 'edge_functions.*.name',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello', name: 'Hello' }] }),
+    },
+    {
+        property: 'edge_functions.*.generator',
+        check: isString,
+        message: 'must be a string.',
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello', generator: 'package-name@1.2.3' }] }),
+    },
     {
         property: 'edge_functions.*.path',
         check: (pathName) => pathName.startsWith('/'),

package/lib/merge_normalize.js

@@ -1,8 +1,8 @@
 import { normalizeConfigCase } from './case.js';
 import { normalizeConfig } from './normalize.js';
-import { addOrigins } from './origin.js';
+import { addOrigins, CONFIG_ORIGIN } from './origin.js';
 import { validateIdenticalPlugins } from './validate/identical.js';
-import { validatePreCaseNormalize, validatePreMergeConfig, validatePreNormalizeConfig, validatePostNormalizeConfig, } from './validate/main.js';
+import { validatePreCaseNormalize, validatePreMergeConfig, validateConfigFile, validatePreNormalizeConfig, validatePostNormalizeConfig, } from './validate/main.js';
 /**
  * Perform validation and normalization logic to apply to all of:
  *  - config, defaultConfig, inlineConfig
@@ -13,6 +13,11 @@ export const normalizeBeforeConfigMerge = function (config, origin) {
     validatePreCaseNormalize(config);
     const configA = normalizeConfigCase(config);
     validatePreMergeConfig(configA);
+    // Some properties are only allowed to be set from the user's `netlify.toml`
+    // file, so they are validated exclusively against that origin.
+    if (origin === CONFIG_ORIGIN) {
+        validateConfigFile(configA);
+    }
     const configB = addOrigins(configA, origin);
     validateIdenticalPlugins(configB);
     return configB;

package/lib/mutations/apply.js

@@ -65,6 +65,7 @@ const MUTABLE_PROPS = {
     images: { lastEvent: 'onPostBuild' },
     'images.remote_images': { lastEvent: 'onPostBuild' },
     redirects: { lastEvent: 'onPostBuild' },
+    spa_fallback: { lastEvent: 'onPostBuild' },
     dev: { lastEvent: 'onPreDev' },
     'dev.processing': { lastEvent: 'onPreDev' },
     'dev.processing.html': { lastEvent: 'onPreDev' },

package/lib/validate/helpers.d.ts

@@ -1,6 +1,7 @@
 export function isArrayOfObjects(value: any): value is Record<PropertyKey, unknown>[];
 export function isArrayOfStrings(value: any): value is string[];
 export function isString(value: any): value is string;
+export function isBoolean(value: any): value is boolean;
 export function validProperties(propNames: any, legacyPropNames: any): {
     check: (value: any) => boolean;
     message: string;

package/lib/validate/helpers.js

@@ -8,6 +8,9 @@ export const isArrayOfStrings = function (value) {
 export const isString = function (value) {
     return typeof value === 'string';
 };
+export const isBoolean = function (value) {
+    return typeof value === 'boolean';
+};
 // Check an object valid properties, including legacy ones
 export const validProperties = function (propNames, legacyPropNames) {
     return {

package/lib/validate/main.d.ts

@@ -1,5 +1,6 @@
 export function validatePreCaseNormalize(config: any): void;
 export function validatePreMergeConfig(config: any): void;
+export function validateConfigFile(config: any): void;
 export function validatePreContextConfig(config: any): void;
 export function validatePreNormalizeConfig(config: any): void;
 export function validatePostNormalizeConfig(config: any): void;

package/lib/validate/main.js

@@ -1,7 +1,7 @@
 import { throwUserError } from '../error.js';
 import { THEME } from '../log/theme.js';
 import { getExample } from './example.js';
-import { PRE_CASE_NORMALIZE_VALIDATIONS, PRE_MERGE_VALIDATIONS, PRE_CONTEXT_VALIDATIONS, PRE_NORMALIZE_VALIDATIONS, POST_NORMALIZE_VALIDATIONS, } from './validations.js';
+import { PRE_CASE_NORMALIZE_VALIDATIONS, PRE_MERGE_VALIDATIONS, PRE_CONTEXT_VALIDATIONS, PRE_NORMALIZE_VALIDATIONS, POST_NORMALIZE_VALIDATIONS, CONFIG_FILE_VALIDATIONS, } from './validations.js';
 // Validate the configuration file, before case normalization.
 export const validatePreCaseNormalize = function (config) {
     validateConfig(config, PRE_CASE_NORMALIZE_VALIDATIONS);
@@ -10,6 +10,13 @@ export const validatePreCaseNormalize = function (config) {
 export const validatePreMergeConfig = function (config) {
     validateConfig(config, PRE_MERGE_VALIDATIONS);
 };
+// Validate properties that are only allowed to be set from the user's
+// configuration file (`netlify.toml`). This runs exclusively on the config
+// coming from that file, so properties reserved for other origins (e.g. the
+// Frameworks API) can still set them.
+export const validateConfigFile = function (config) {
+    validateConfig(config, CONFIG_FILE_VALIDATIONS);
+};
 // Validate the configuration file, before context merge.
 export const validatePreContextConfig = function (config) {
     validateConfig(config, PRE_CONTEXT_VALIDATIONS);

package/lib/validate/validations.d.ts

@@ -8,6 +8,17 @@ export const PRE_CASE_NORMALIZE_VALIDATIONS: {
         };
     };
 }[];
+export const CONFIG_FILE_VALIDATIONS: {
+    check: (edgeFunction: any) => boolean;
+    example: () => {
+        edge_functions: {
+            path: string;
+            function: string;
+        }[];
+    };
+    message: string;
+    property: string;
+}[];
 export const PRE_MERGE_VALIDATIONS: ({
     property: string;
     check: (value: any) => value is string;
@@ -204,6 +215,13 @@ export const POST_NORMALIZE_VALIDATIONS: ({
             edge_functions: string;
         };
     };
+} | {
+    property: string;
+    check: (value: any) => value is boolean;
+    message: string;
+    example: () => {
+        spa_fallback: boolean;
+    };
 } | {
     property: string;
     check: typeof isPlainObj;

package/lib/validate/validations.js

@@ -1,9 +1,9 @@
 import CronParser from 'cron-parser';
 import isPlainObj from 'is-plain-obj';
 import validateNpmPackageName from 'validate-npm-package-name';
-import { validations as edgeFunctionValidations } from '../edge_functions.js';
+import { validations as edgeFunctionValidations, EDGE_FUNCTIONS_PROPERTIES } from '../edge_functions.js';
 import { bundlers, WILDCARD_ALL as FUNCTIONS_CONFIG_WILDCARD_ALL } from '../functions_config.js';
-import { functionsDirectoryCheck, isArrayOfObjects, isArrayOfStrings, isString, validProperties } from './helpers.js';
+import { functionsDirectoryCheck, isArrayOfObjects, isArrayOfStrings, isBoolean, isString, validProperties, } from './helpers.js';
 /**
  * @param {string} cron
  * @returns {boolean}
@@ -40,6 +40,24 @@ export const PRE_CASE_NORMALIZE_VALIDATIONS = [
         example: () => ({ build: { command: 'npm run build' } }),
     },
 ];
+const edgeFunctionsUserProperties = validProperties(EDGE_FUNCTIONS_PROPERTIES, []);
+// Validations performed only on the user's configuration file (`netlify.toml`),
+// i.e. not on configuration coming from other origins such as the UI, the CLI,
+// or the Frameworks API. This is where the schema is restricted to the subset
+// of properties that users are allowed to set, excluding those reserved for
+// platform-generated configuration (e.g. `generator`).
+export const CONFIG_FILE_VALIDATIONS = [
+    {
+        property: 'edge_functions.*',
+        ...edgeFunctionsUserProperties,
+        // Structural problems, such as an entry that is not an object, are reported
+        // by the shared `edge_functions` validations, which run later. We only check
+        // the properties of actual objects here, so that those validations remain
+        // the ones surfacing a meaningful error.
+        check: (edgeFunction) => !isPlainObj(edgeFunction) || edgeFunctionsUserProperties.check(edgeFunction),
+        example: () => ({ edge_functions: [{ path: '/hello', function: 'hello' }] }),
+    },
+];
 // Properties with an `origin` property need to be validated twice:
 //  - Before the `origin` property is added
 //  - After `context.*` is merged, since they might contain that property
@@ -191,6 +209,12 @@ export const POST_NORMALIZE_VALIDATIONS = [
         message: 'must be a string.',
         example: () => ({ build: { edge_functions: 'edge-functions' } }),
     },
+    {
+        property: 'spa_fallback',
+        check: isBoolean,
+        message: 'must be a boolean.',
+        example: () => ({ spa_fallback: true }),
+    },
     {
         property: 'functions.*',
         check: isPlainObj,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/config",
-  "version": "25.1.0",
+  "version": "25.2.0",
   "description": "Netlify config module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -96,5 +96,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "0a4aa4be3f9abbb49ebe00e82c64898148986715"
+  "gitHead": "f34dd81fc3bc8925aabe5cf9c1cdce4e8eebc4e0"
 }