@netlify/edge-bundler 8.12.0 → 8.12.2

package/dist/node/bundler.d.ts

@@ -25,8 +25,8 @@ export declare const addGeneratorFieldIfMissing: (declaration: Declaration, func
     cache?: string | undefined;
     function: string;
     name?: string | undefined;
-    path: string;
-    excludedPath?: string | undefined;
+    path: `/${string}`;
+    excludedPath?: `/${string}` | undefined;
 } | {
     generator: string | undefined;
     cache?: string | undefined;

package/dist/node/config.d.ts

@@ -7,12 +7,13 @@ export declare const enum Cache {
     Off = "off",
     Manual = "manual"
 }
+export type Path = `/${string}`;
 export type OnError = 'fail' | 'bypass' | `/${string}`;
 export declare const isValidOnError: (value: unknown) => value is OnError;
 export interface FunctionConfig {
     cache?: Cache;
-    path?: string | string[];
-    excludedPath?: string | string[];
+    path?: Path | Path[];
+    excludedPath?: Path | Path[];
     onError?: OnError;
 }
 export declare const getFunctionConfig: (func: EdgeFunction, importMap: ImportMap, deno: DenoBridge, log: Logger, featureFlags: FeatureFlags) => Promise<FunctionConfig>;

package/dist/node/declaration.d.ts

@@ -1,4 +1,4 @@
-import { FunctionConfig } from './config.js';
+import { FunctionConfig, Path } from './config.js';
 interface BaseDeclaration {
     cache?: string;
     function: string;
@@ -6,8 +6,8 @@ interface BaseDeclaration {
     generator?: string;
 }
 type DeclarationWithPath = BaseDeclaration & {
-    path: string;
-    excludedPath?: string;
+    path: Path;
+    excludedPath?: Path;
 };
 type DeclarationWithPattern = BaseDeclaration & {
     pattern: string;

package/dist/node/feature_flags.d.ts

@@ -1,12 +1,14 @@
 declare const defaultFlags: {
     edge_functions_fail_unsupported_regex: boolean;
     edge_functions_invalid_config_throw: boolean;
+    edge_functions_manifest_validate_slash: boolean;
 };
 type FeatureFlag = keyof typeof defaultFlags;
 type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
 declare const getFlags: (input?: Record<string, boolean>, flags?: {
     edge_functions_fail_unsupported_regex: boolean;
     edge_functions_invalid_config_throw: boolean;
+    edge_functions_manifest_validate_slash: boolean;
 }) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

package/dist/node/feature_flags.js

@@ -1,6 +1,7 @@
 const defaultFlags = {
     edge_functions_fail_unsupported_regex: false,
     edge_functions_invalid_config_throw: false,
+    edge_functions_manifest_validate_slash: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/formats/javascript.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
-const defaultFormatImpoortError = (name) => `There was an error with Edge Function "${name}".`;
+const defaultFormatImportError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ bootstrapURL, distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {
     await deleteAsync(distDirectory, { force: true });
     await fs.mkdir(distDirectory, { recursive: true });
@@ -15,7 +15,7 @@ const generateStage2 = async ({ bootstrapURL, distDirectory, fileName, formatExp
 // For the local development environment, we import the user functions with
 // dynamic imports to gracefully handle the case where the file doesn't have
 // a valid default export.
-const getLocalEntryPoint = (functions, { bootstrapURL, formatExportTypeError = defaultFormatExportTypeError, formatImportError = defaultFormatImpoortError, }) => {
+const getLocalEntryPoint = (functions, { bootstrapURL, formatExportTypeError = defaultFormatExportTypeError, formatImportError = defaultFormatImportError, }) => {
     const bootImport = `import { boot } from "${bootstrapURL}";`;
     const declaration = `const functions = {}; const metadata = { functions: {} };`;
     const imports = functions.map((func) => {

package/dist/node/manifest.js

@@ -23,6 +23,10 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
     const postCacheRoutes = [];
     const manifestFunctionConfig = Object.fromEntries(functions.map(({ name }) => [name, { excluded_patterns: [] }]));
     for (const [name, { excludedPath, onError }] of Object.entries(functionConfig)) {
+        // If the config block is for a function that is not defined, discard it.
+        if (manifestFunctionConfig[name] === undefined) {
+            continue;
+        }
         if (excludedPath) {
             const paths = Array.isArray(excludedPath) ? excludedPath : [excludedPath];
             const excludedPatterns = paths.map(pathToRegularExpression).map(serializePattern);

package/dist/node/validation/manifest/index.d.ts

@@ -1,3 +1,4 @@
+import { FeatureFlags } from '../../feature_flags.js';
 import ManifestValidationError from './error.js';
-export declare const validateManifest: (manifestData: unknown) => void;
+export declare const validateManifest: (manifestData: unknown, featureFlags?: FeatureFlags) => void;
 export { ManifestValidationError };

package/dist/node/validation/manifest/index.js

@@ -4,13 +4,13 @@ import betterAjvErrors from 'better-ajv-errors';
 import ManifestValidationError from './error.js';
 import edgeManifestSchema from './schema.js';
 let manifestValidator;
-const initializeValidator = () => {
+const initializeValidator = (featureFlags) => {
     if (manifestValidator === undefined) {
         const ajv = new Ajv({ allErrors: true });
         ajvErrors(ajv);
         // regex pattern for manifest route pattern
         // checks if the pattern string starts with ^ and ends with $
-        const normalizedPatternRegex = /^\^.*\$$/;
+        const normalizedPatternRegex = featureFlags.edge_functions_manifest_validate_slash ? /^\^\/.*\$$/ : /^\^.*\$$/;
         ajv.addFormat('regexPattern', {
             validate: (data) => normalizedPatternRegex.test(data),
         });
@@ -19,8 +19,8 @@ const initializeValidator = () => {
     return manifestValidator;
 };
 // throws on validation error
-export const validateManifest = (manifestData) => {
-    const validate = initializeValidator();
+export const validateManifest = (manifestData, featureFlags = {}) => {
+    const validate = initializeValidator(featureFlags);
     const valid = validate(manifestData);
     if (!valid) {
         let errorOutput;

package/dist/node/validation/manifest/index.test.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { test, expect, describe } from 'vitest';
+import { test, expect, describe, beforeEach, vi } from 'vitest';
 import { validateManifest, ManifestValidationError } from './index.js';
 // We need to disable all color outputs for the tests as they are different on different platforms, CI, etc.
 // This only works if this is the same instance of chalk that better-ajv-errors uses
@@ -79,25 +79,42 @@ describe('bundle', () => {
     });
 });
 describe('route', () => {
+    let freshValidateManifest;
+    beforeEach(async () => {
+        // reset all modules, to get a fresh AJV validator for FF changes
+        vi.resetModules();
+        const indexImport = await import('./index.js');
+        freshValidateManifest = indexImport.validateManifest;
+    });
     test('should throw on additional property', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].foo = 'bar';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on invalid pattern', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].pattern = '/^/hello/?$/';
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should not throw on missing beginning slash without FF', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].pattern = '^hello/?$';
+        expect(() => freshValidateManifest(manifest, { edge_functions_manifest_validate_slash: false })).not.toThrowError();
+    });
+    test('should throw on missing beginning slash with FF', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].pattern = '^hello/?$';
+        expect(() => freshValidateManifest(manifest, { edge_functions_manifest_validate_slash: true })).toThrowErrorMatchingSnapshot();
     });
     test('should throw on missing function', () => {
         const manifest = getBaseManifest();
         delete manifest.routes[0].function;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on missing pattern', () => {
         const manifest = getBaseManifest();
         delete manifest.routes[0].pattern;
-        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
 });
 // No tests for post_cache_routes as schema shared with routes

package/dist/node/validation/manifest/schema.js

@@ -16,7 +16,7 @@ const routesSchema = {
         pattern: {
             type: 'string',
             format: 'regexPattern',
-            errorMessage: 'pattern needs to be a regex that starts with ^ and ends with $ without any additional slashes before and afterwards',
+            errorMessage: 'pattern needs to be a regex that starts with ^ followed by / and ends with $ without any additional slashes before and afterwards',
         },
         generator: { type: 'string' },
     },
@@ -31,7 +31,7 @@ const functionConfigSchema = {
             items: {
                 type: 'string',
                 format: 'regexPattern',
-                errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ and ends with $ without any additional slashes before and afterwards',
+                errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ followed by / and ends with $ without any additional slashes before and afterwards',
             },
         },
         on_error: { type: 'string' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.12.0",
+  "version": "8.12.2",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -57,9 +57,8 @@
     "@types/glob-to-regexp": "^0.4.1",
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
-    "@types/sinon": "^10.0.8",
     "@types/uuid": "^9.0.0",
-    "@vitest/coverage-c8": "^0.25.0",
+    "@vitest/coverage-c8": "^0.29.2",
     "archiver": "^5.3.1",
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
@@ -68,8 +67,7 @@
     "nock": "^13.2.4",
     "tar": "^6.1.11",
     "typescript": "^4.5.4",
-    "vite": "^4.0.0",
-    "vitest": "^0.25.0"
+    "vitest": "^0.29.2"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"