@netlify/edge-bundler 4.3.2 → 4.4.0

package/dist/node/bridge.d.ts

@@ -2,8 +2,8 @@
 import { ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';
 declare const DENO_VERSION_RANGE = "^1.22.0";
-declare type OnBeforeDownloadHook = () => void | Promise<void>;
-declare type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
+type OnBeforeDownloadHook = () => void | Promise<void>;
+type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 interface DenoOptions {
     cacheDirectory?: string;
     debug?: boolean;

package/dist/node/bundle.d.ts

@@ -1,6 +1,9 @@
-interface Bundle {
+export declare enum BundleFormat {
+    ESZIP2 = "eszip2",
+    JS = "js"
+}
+export interface Bundle {
     extension: string;
-    format: string;
+    format: BundleFormat;
     hash: string;
 }
-export type { Bundle };

package/dist/node/bundle.js

@@ -1 +1,5 @@
-export {};
+export var BundleFormat;
+(function (BundleFormat) {
+    BundleFormat["ESZIP2"] = "eszip2";
+    BundleFormat["JS"] = "js";
+})(BundleFormat || (BundleFormat = {}));

package/dist/node/declaration.d.ts

@@ -4,12 +4,12 @@ interface BaseDeclaration {
     function: string;
     name?: string;
 }
-declare type DeclarationWithPath = BaseDeclaration & {
+type DeclarationWithPath = BaseDeclaration & {
     path: string;
 };
-declare type DeclarationWithPattern = BaseDeclaration & {
+type DeclarationWithPattern = BaseDeclaration & {
     pattern: string;
 };
-declare type Declaration = DeclarationWithPath | DeclarationWithPattern;
+type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const getDeclarationsFromConfig: (tomlDeclarations: Declaration[], functionsConfig: Record<string, FunctionConfig>) => Declaration[];
 export { Declaration, DeclarationWithPath, DeclarationWithPattern };

package/dist/node/feature_flags.d.ts

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

package/dist/node/formats/eszip.d.ts

@@ -1,5 +1,5 @@
 import { DenoBridge } from '../bridge.js';
-import type { Bundle } from '../bundle.js';
+import { Bundle } from '../bundle.js';
 import { EdgeFunction } from '../edge_function.js';
 import { FeatureFlags } from '../feature_flags.js';
 import { ImportMap } from '../import_map.js';

package/dist/node/formats/eszip.js

@@ -1,4 +1,5 @@
 import { join } from 'path';
+import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
@@ -27,7 +28,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, func
         throw wrapBundleError(wrapNpmImportError(error), { format: 'eszip' });
     }
     const hash = await getFileHash(destPath);
-    return { extension, format: 'eszip2', hash };
+    return { extension, format: BundleFormat.ESZIP2, hash };
 };
 const getESZIPPaths = () => {
     const denoPath = join(getPackagePath(), 'deno');

package/dist/node/formats/javascript.d.ts

@@ -1,5 +1,5 @@
 import { DenoBridge } from '../bridge.js';
-import type { Bundle } from '../bundle.js';
+import { Bundle } from '../bundle.js';
 import { EdgeFunction } from '../edge_function.js';
 import { ImportMap } from '../import_map.js';
 import type { FormatFunction } from '../server/server.js';

package/dist/node/formats/javascript.js

@@ -3,6 +3,7 @@ import { join } from 'path';
 import { env } from 'process';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
+import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getFileHash } from '../utils/sha256.js';
@@ -23,7 +24,7 @@ const bundleJS = async ({ buildID, debug, deno, distDirectory, functions, import
     }
     await fs.unlink(stage2Path);
     const hash = await getFileHash(jsBundlePath);
-    return { extension, format: 'js', hash };
+    return { extension, format: BundleFormat.JS, hash };
 };
 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}".`;

package/dist/node/index.d.ts

@@ -3,3 +3,4 @@ export { DenoBridge } from './bridge.js';
 export { findFunctions as find } from './finder.js';
 export { generateManifest } from './manifest.js';
 export { serve } from './server/server.js';
+export { validateManifest, ManifestValidationError } from './validation/manifest/index.js';

package/dist/node/index.js

@@ -3,3 +3,4 @@ export { DenoBridge } from './bridge.js';
 export { findFunctions as find } from './finder.js';
 export { generateManifest } from './manifest.js';
 export { serve } from './server/server.js';
+export { validateManifest, ManifestValidationError } from './validation/manifest/index.js';

package/dist/node/logger.d.ts

@@ -1,4 +1,4 @@
-declare type LogFunction = (...args: unknown[]) => void;
+type LogFunction = (...args: unknown[]) => void;
 interface Logger {
     system: LogFunction;
     user: LogFunction;

package/dist/node/manifest.test.js

@@ -1,15 +1,16 @@
 import { env } from 'process';
 import { test, expect } from 'vitest';
+import { BundleFormat } from './bundle.js';
 import { generateManifest } from './manifest.js';
 test('Generates a manifest with different bundles', () => {
     const bundle1 = {
         extension: '.ext1',
-        format: 'format1',
+        format: BundleFormat.ESZIP2,
         hash: '123456',
     };
     const bundle2 = {
         extension: '.ext2',
-        format: 'format2',
+        format: BundleFormat.ESZIP2,
         hash: '654321',
     };
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
@@ -44,7 +45,7 @@ test('Generates a manifest with display names', () => {
 test('Excludes functions for which there are function files but no matching config declarations', () => {
     const bundle1 = {
         extension: '.ext2',
-        format: 'format1',
+        format: BundleFormat.ESZIP2,
         hash: '123456',
     };
     const functions = [
@@ -59,7 +60,7 @@ test('Excludes functions for which there are function files but no matching conf
 test('Excludes functions for which there are config declarations but no matching function files', () => {
     const bundle1 = {
         extension: '.ext2',
-        format: 'format1',
+        format: BundleFormat.ESZIP2,
         hash: '123456',
     };
     const functions = [{ name: 'func-2', path: '/path/to/func-2.ts' }];
@@ -83,12 +84,12 @@ test('Generates a manifest without bundles', () => {
 test('Generates a manifest with pre and post-cache routes', () => {
     const bundle1 = {
         extension: '.ext1',
-        format: 'format1',
+        format: BundleFormat.ESZIP2,
         hash: '123456',
     };
     const bundle2 = {
         extension: '.ext2',
-        format: 'format2',
+        format: BundleFormat.ESZIP2,
         hash: '654321',
     };
     const functions = [

package/dist/node/server/server.d.ts

@@ -8,7 +8,7 @@ import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
 import { ImportMapFile } from '../import_map.js';
 import { LogFunction } from '../logger.js';
-declare type FormatFunction = (name: string) => string;
+type FormatFunction = (name: string) => string;
 interface StartServerOptions {
     getFunctionsConfig?: boolean;
 }

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

@@ -0,0 +1,3 @@
+export default class ManifestValidationError extends Error {
+    constructor(message: string | undefined);
+}

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

@@ -0,0 +1,8 @@
+export default class ManifestValidationError extends Error {
+    constructor(message) {
+        super(`Validation of Edge Functions manifest failed\n${message}`);
+        this.name = 'ManifestValidationError';
+        // https://github.com/microsoft/TypeScript-wiki/blob/0fecbda7263f130c57394d779b8ca13f0a2e9123/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(this, ManifestValidationError.prototype);
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+import Ajv from 'ajv';
+import ajvErrors from 'ajv-errors';
+import betterAjvErrors from 'better-ajv-errors';
+import ManifestValidationError from './error.js';
+import edgeManifestSchema from './schema.js';
+let manifestValidator;
+const initializeValidator = () => {
+    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 = /^\^.*\$$/;
+        ajv.addFormat('regexPattern', {
+            validate: (data) => normalizedPatternRegex.test(data),
+        });
+        manifestValidator = ajv.compile(edgeManifestSchema);
+    }
+    return manifestValidator;
+};
+// throws on validation error
+export const validateManifest = (manifestData) => {
+    const validate = initializeValidator();
+    const valid = validate(manifestData);
+    if (!valid) {
+        let errorOutput;
+        if (validate.errors) {
+            errorOutput = betterAjvErrors(edgeManifestSchema, manifestData, validate.errors, { indent: 2 });
+        }
+        throw new ManifestValidationError(errorOutput);
+    }
+};
+// eslint-disable-next-line unicorn/prefer-export-from
+export { ManifestValidationError };

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,116 @@
+/* eslint-disable max-nested-callbacks */
+import { test, expect, describe } from 'vitest';
+import { validateManifest, ManifestValidationError } from './index.js';
+// Factory so we have a new object per test
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const getBaseManifest = () => ({
+    bundles: [
+        {
+            asset: 'f35baff44129a8f6be7db68590b2efd86ed4ba29000e2edbcaddc5d620d7d043.js',
+            format: 'js',
+        },
+    ],
+    routes: [
+        {
+            name: 'name',
+            function: 'hello',
+            pattern: '^/hello/?$',
+        },
+    ],
+    post_cache_routes: [
+        {
+            name: 'name',
+            function: 'hello',
+            pattern: '^/hello/?$',
+        },
+    ],
+    layers: [
+        {
+            flag: 'flag',
+            name: 'name',
+            local: 'local',
+        },
+    ],
+    bundler_version: '1.6.0',
+});
+test('should not throw on valid manifest', () => {
+    expect(() => validateManifest(getBaseManifest())).not.toThrowError();
+});
+test('should throw ManifestValidationError with correct message', () => {
+    expect(() => validateManifest('manifest')).toThrowError(ManifestValidationError);
+    expect(() => validateManifest('manifest')).toThrowError(/^Validation of Edge Functions manifest failed/);
+});
+test('should throw on additional property on root level', () => {
+    const manifest = getBaseManifest();
+    manifest.foo = 'bar';
+    expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+});
+test('should show multiple errors', () => {
+    const manifest = getBaseManifest();
+    manifest.foo = 'bar';
+    manifest.baz = 'bar';
+    expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+});
+describe('bundle', () => {
+    test('should throw on additional property in bundle', () => {
+        const manifest = getBaseManifest();
+        manifest.bundles[0].foo = 'bar';
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on missing asset', () => {
+        const manifest = getBaseManifest();
+        delete manifest.bundles[0].asset;
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on missing format', () => {
+        const manifest = getBaseManifest();
+        delete manifest.bundles[0].format;
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on invalid format', () => {
+        const manifest = getBaseManifest();
+        manifest.bundles[0].format = 'foo';
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+});
+describe('route', () => {
+    test('should throw on additional property', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].foo = 'bar';
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on invalid pattern', () => {
+        const manifest = getBaseManifest();
+        manifest.routes[0].pattern = '/^/hello/?$/';
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on missing function', () => {
+        const manifest = getBaseManifest();
+        delete manifest.routes[0].function;
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on missing pattern', () => {
+        const manifest = getBaseManifest();
+        delete manifest.routes[0].pattern;
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+});
+// No tests for post_cache_routes as schema shared with routes
+describe('layers', () => {
+    test('should throw on additional property', () => {
+        const manifest = getBaseManifest();
+        manifest.layers[0].foo = 'bar';
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on missing name', () => {
+        const manifest = getBaseManifest();
+        delete manifest.layers[0].name;
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+    test('should throw on missing flag', () => {
+        const manifest = getBaseManifest();
+        delete manifest.layers[0].flag;
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
+    });
+});
+/* eslint-enable max-nested-callbacks */

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

@@ -0,0 +1,89 @@
+declare const edgeManifestSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        bundles: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    asset: {
+                        type: string;
+                    };
+                    format: {
+                        type: string;
+                        enum: string[];
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        routes: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    function: {
+                        type: string;
+                    };
+                    pattern: {
+                        type: string;
+                        format: string;
+                        errorMessage: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        post_cache_routes: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    function: {
+                        type: string;
+                    };
+                    pattern: {
+                        type: string;
+                        format: string;
+                        errorMessage: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        layers: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    flag: {
+                        type: string;
+                    };
+                    name: {
+                        type: string;
+                    };
+                    local: {
+                        type: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        bundler_version: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export default edgeManifestSchema;

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

@@ -0,0 +1,58 @@
+const bundlesSchema = {
+    type: 'object',
+    required: ['asset', 'format'],
+    properties: {
+        asset: { type: 'string' },
+        format: { type: 'string', enum: ['eszip2', 'js'] },
+    },
+    additionalProperties: false,
+};
+const routesSchema = {
+    type: 'object',
+    required: ['function', 'pattern'],
+    properties: {
+        name: { type: 'string' },
+        function: { type: 'string' },
+        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',
+        },
+    },
+    additionalProperties: false,
+};
+const layersSchema = {
+    type: 'object',
+    required: ['flag', 'name'],
+    properties: {
+        flag: { type: 'string' },
+        name: { type: 'string' },
+        local: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+const edgeManifestSchema = {
+    type: 'object',
+    required: ['bundles', 'routes', 'bundler_version'],
+    properties: {
+        bundles: {
+            type: 'array',
+            items: bundlesSchema,
+        },
+        routes: {
+            type: 'array',
+            items: routesSchema,
+        },
+        post_cache_routes: {
+            type: 'array',
+            items: routesSchema,
+        },
+        layers: {
+            type: 'array',
+            items: layersSchema,
+        },
+        bundler_version: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+export default edgeManifestSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "4.3.2",
+  "version": "4.4.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -28,9 +28,9 @@
     "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
     "test:dev": "run-s test:dev:*",
     "test:ci": "run-s test:ci:*",
-    "test:dev:vitest": "vitest run",
+    "test:dev:vitest": "cross-env FORCE_COLOR=0 vitest run",
     "test:dev:deno": "deno test --allow-all deno",
-    "test:ci:vitest": "vitest run",
+    "test:ci:vitest": "cross-env FORCE_COLOR=0 vitest run",
     "test:ci:deno": "deno test --allow-all deno",
     "test:integration": "node --experimental-modules test/integration/test.js"
   },
@@ -59,6 +59,7 @@
     "@types/uuid": "^8.3.4",
     "@vitest/coverage-c8": "^0.25.0",
     "archiver": "^5.3.1",
+    "cross-env": "^7.0.3",
     "husky": "^8.0.0",
     "nock": "^13.2.4",
     "tar": "^6.1.11",
@@ -71,6 +72,9 @@
   },
   "dependencies": {
     "@import-maps/resolve": "^1.0.1",
+    "ajv": "^8.11.2",
+    "ajv-errors": "^3.0.0",
+    "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "del": "^7.0.0",
     "env-paths": "^3.0.0",