@netlify/dev 4.1.1 → 4.1.3

package/dist/main.cjs

@@ -345,37 +345,50 @@ var NetlifyDev = class {
     this.#projectRoot = projectRoot;
     this.#staticHandlerAdditionalDirectories = options.staticFiles?.directories ?? [];
   }
-  async handleInEphemeralDirectory(matchRequest, getHandleRequest, destPath, options = {}) {
-    const edgeFunctionMatch = await this.#edgeFunctionsHandler?.match(matchRequest);
+  /**
+   * Runs a request through the Netlify request chain and returns a `Response`
+   * if there's a match. We must not disturb the incoming request unless we
+   * know we will be returning a response, so this method takes a read-only
+   * request that is safe to access (used for matching) and a getter for the
+   * actual request (used for handling matches).
+   *
+   * @param readRequest Read-only version of the request (without a body)
+   * @param getWriteRequest Getter for the actual request (with a body)
+   * @param destPath Destination directory for compiled files
+   * @param options Options object
+   * @returns
+   */
+  async handleInEphemeralDirectory(readRequest, getWriteRequest, destPath, options = {}) {
+    const edgeFunctionMatch = await this.#edgeFunctionsHandler?.match(readRequest);
     if (edgeFunctionMatch) {
       return {
-        response: await edgeFunctionMatch.handle(getHandleRequest()),
+        response: await edgeFunctionMatch.handle(getWriteRequest()),
         type: "edge-function"
       };
     }
-    const functionMatch = await this.#functionsHandler?.match(matchRequest, destPath);
+    const functionMatch = await this.#functionsHandler?.match(readRequest, destPath);
     if (functionMatch) {
       if (functionMatch.preferStatic) {
-        const staticMatch2 = await this.#staticHandler?.match(matchRequest);
+        const staticMatch2 = await this.#staticHandler?.match(readRequest);
         if (staticMatch2) {
           const response = await staticMatch2.handle();
-          await this.#headersHandler?.apply(matchRequest, response, options.headersCollector);
+          await this.#headersHandler?.apply(readRequest, response, options.headersCollector);
           return { response, type: "static" };
         }
       }
-      return { response: await functionMatch.handle(getHandleRequest()), type: "function" };
+      return { response: await functionMatch.handle(getWriteRequest()), type: "function" };
     }
-    const redirectMatch = await this.#redirectsHandler?.match(matchRequest);
+    const redirectMatch = await this.#redirectsHandler?.match(readRequest);
     if (redirectMatch) {
       const functionMatch2 = await this.#functionsHandler?.match(new Request(redirectMatch.target), destPath);
       if (functionMatch2 && !functionMatch2.preferStatic) {
         return {
-          response: await functionMatch2.handle(getHandleRequest()),
+          response: await functionMatch2.handle(getWriteRequest()),
           type: "function"
         };
       }
       const response = await this.#redirectsHandler?.handle(
-        getHandleRequest(),
+        getWriteRequest(),
         redirectMatch,
         async (maybeStaticFile) => {
           const staticMatch2 = await this.#staticHandler?.match(maybeStaticFile);
@@ -393,17 +406,17 @@ var NetlifyDev = class {
         return { response, type: "redirect" };
       }
     }
-    const { pathname } = new URL(matchRequest.url);
+    const { pathname } = new URL(readRequest.url);
     if (pathname.startsWith("/.netlify/images")) {
       this.#logger.error(
-        "The Netlify Image CDN is currently only supported in the Netlify CLI. Run `npx netlify dev` to get started."
+        `The Netlify Image CDN is currently only supported in the Netlify CLI. Run ${(0, import_dev_utils.netlifyCommand)("npx netlify dev")} to get started.`
       );
       return;
     }
-    const staticMatch = await this.#staticHandler?.match(matchRequest);
+    const staticMatch = await this.#staticHandler?.match(readRequest);
     if (staticMatch) {
       const response = await staticMatch.handle();
-      await this.#headersHandler?.apply(matchRequest, response, options.headersCollector);
+      await this.#headersHandler?.apply(readRequest, response, options.headersCollector);
       return { response, type: "static" };
     }
   }
@@ -424,10 +437,19 @@ var NetlifyDev = class {
     });
     return config;
   }
+  /**
+   * Runs a `Request` through the Netlify request chain. If there is a match,
+   * it returns the resulting `Response` object; if not, it returns `undefined`.
+   */
   async handle(request, options = {}) {
     const result = await this.handleAndIntrospect(request, options);
     return result?.response;
   }
+  /**
+   * Runs a `Request` through the Netlify request chain. If there is a match,
+   * it returns an object with the resulting `Response` object and information
+   * about the match; if not, it returns `undefined`.
+   */
   async handleAndIntrospect(request, options = {}) {
     await import_node_fs2.promises.mkdir(this.#functionsServePath, { recursive: true });
     const destPath = await import_node_fs2.promises.mkdtemp(import_node_path2.default.join(this.#functionsServePath, `_`));
@@ -443,6 +465,11 @@ var NetlifyDev = class {
       }
     }
   }
+  /**
+   * Runs a Node.js `IncomingMessage` through the Netlify request chain. If
+   * there is a match, it returns an object with the resulting `Response`
+   * object and information about the match; if not, it returns `undefined`.
+   */
   async handleAndIntrospectNodeRequest(request, options = {}) {
     await import_node_fs2.promises.mkdir(this.#functionsServePath, { recursive: true });
     const destPath = await import_node_fs2.promises.mkdtemp(import_node_path2.default.join(this.#functionsServePath, `_`));
@@ -566,6 +593,9 @@ var NetlifyDev = class {
   async stop() {
     await Promise.allSettled(this.#cleanupJobs.map((task) => task()));
   }
+  getEnabledFeatures() {
+    return Object.entries(this.#features).filter(([_, enabled]) => enabled).map(([feature]) => feature);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/main.d.cts

@@ -87,13 +87,40 @@ type ResponseType = 'edge-function' | 'function' | 'redirect' | 'static';
 declare class NetlifyDev {
     #private;
     constructor(options: NetlifyDevOptions);
+    /**
+     * Runs a request through the Netlify request chain and returns a `Response`
+     * if there's a match. We must not disturb the incoming request unless we
+     * know we will be returning a response, so this method takes a read-only
+     * request that is safe to access (used for matching) and a getter for the
+     * actual request (used for handling matches).
+     *
+     * @param readRequest Read-only version of the request (without a body)
+     * @param getWriteRequest Getter for the actual request (with a body)
+     * @param destPath Destination directory for compiled files
+     * @param options Options object
+     * @returns
+     */
     private handleInEphemeralDirectory;
     private getConfig;
+    /**
+     * Runs a `Request` through the Netlify request chain. If there is a match,
+     * it returns the resulting `Response` object; if not, it returns `undefined`.
+     */
     handle(request: Request, options?: HandleOptions): Promise<Response | undefined>;
+    /**
+     * Runs a `Request` through the Netlify request chain. If there is a match,
+     * it returns an object with the resulting `Response` object and information
+     * about the match; if not, it returns `undefined`.
+     */
     handleAndIntrospect(request: Request, options?: HandleOptions): Promise<{
         response: Response;
         type: ResponseType;
     } | undefined>;
+    /**
+     * Runs a Node.js `IncomingMessage` through the Netlify request chain. If
+     * there is a match, it returns an object with the resulting `Response`
+     * object and information about the match; if not, it returns `undefined`.
+     */
     handleAndIntrospectNodeRequest(request: IncomingMessage, options?: HandleOptions): Promise<{
         response: Response;
         type: ResponseType;
@@ -103,6 +130,7 @@ declare class NetlifyDev {
         serverAddress: string | undefined;
     }>;
     stop(): Promise<void>;
+    getEnabledFeatures(): string[];
 }
 
 export { type Features, NetlifyDev, type ResponseType };

package/dist/main.d.ts

@@ -87,13 +87,40 @@ type ResponseType = 'edge-function' | 'function' | 'redirect' | 'static';
 declare class NetlifyDev {
     #private;
     constructor(options: NetlifyDevOptions);
+    /**
+     * Runs a request through the Netlify request chain and returns a `Response`
+     * if there's a match. We must not disturb the incoming request unless we
+     * know we will be returning a response, so this method takes a read-only
+     * request that is safe to access (used for matching) and a getter for the
+     * actual request (used for handling matches).
+     *
+     * @param readRequest Read-only version of the request (without a body)
+     * @param getWriteRequest Getter for the actual request (with a body)
+     * @param destPath Destination directory for compiled files
+     * @param options Options object
+     * @returns
+     */
     private handleInEphemeralDirectory;
     private getConfig;
+    /**
+     * Runs a `Request` through the Netlify request chain. If there is a match,
+     * it returns the resulting `Response` object; if not, it returns `undefined`.
+     */
     handle(request: Request, options?: HandleOptions): Promise<Response | undefined>;
+    /**
+     * Runs a `Request` through the Netlify request chain. If there is a match,
+     * it returns an object with the resulting `Response` object and information
+     * about the match; if not, it returns `undefined`.
+     */
     handleAndIntrospect(request: Request, options?: HandleOptions): Promise<{
         response: Response;
         type: ResponseType;
     } | undefined>;
+    /**
+     * Runs a Node.js `IncomingMessage` through the Netlify request chain. If
+     * there is a match, it returns an object with the resulting `Response`
+     * object and information about the match; if not, it returns `undefined`.
+     */
     handleAndIntrospectNodeRequest(request: IncomingMessage, options?: HandleOptions): Promise<{
         response: Response;
         type: ResponseType;
@@ -103,6 +130,7 @@ declare class NetlifyDev {
         serverAddress: string | undefined;
     }>;
     stop(): Promise<void>;
+    getEnabledFeatures(): string[];
 }
 
 export { type Features, NetlifyDev, type ResponseType };

package/dist/main.js

@@ -3,7 +3,14 @@ import { promises as fs2 } from "fs";
 import path2 from "path";
 import process2 from "process";
 import { resolveConfig } from "@netlify/config";
-import { ensureNetlifyIgnore, getAPIToken, mockLocation, LocalState, HTTPServer } from "@netlify/dev-utils";
+import {
+  ensureNetlifyIgnore,
+  getAPIToken,
+  mockLocation,
+  LocalState,
+  HTTPServer,
+  netlifyCommand
+} from "@netlify/dev-utils";
 import { EdgeFunctionsHandler } from "@netlify/edge-functions/dev";
 import { FunctionsHandler } from "@netlify/functions/dev";
 import { HeadersHandler } from "@netlify/headers";
@@ -311,37 +318,50 @@ var NetlifyDev = class {
     this.#projectRoot = projectRoot;
     this.#staticHandlerAdditionalDirectories = options.staticFiles?.directories ?? [];
   }
-  async handleInEphemeralDirectory(matchRequest, getHandleRequest, destPath, options = {}) {
-    const edgeFunctionMatch = await this.#edgeFunctionsHandler?.match(matchRequest);
+  /**
+   * Runs a request through the Netlify request chain and returns a `Response`
+   * if there's a match. We must not disturb the incoming request unless we
+   * know we will be returning a response, so this method takes a read-only
+   * request that is safe to access (used for matching) and a getter for the
+   * actual request (used for handling matches).
+   *
+   * @param readRequest Read-only version of the request (without a body)
+   * @param getWriteRequest Getter for the actual request (with a body)
+   * @param destPath Destination directory for compiled files
+   * @param options Options object
+   * @returns
+   */
+  async handleInEphemeralDirectory(readRequest, getWriteRequest, destPath, options = {}) {
+    const edgeFunctionMatch = await this.#edgeFunctionsHandler?.match(readRequest);
     if (edgeFunctionMatch) {
       return {
-        response: await edgeFunctionMatch.handle(getHandleRequest()),
+        response: await edgeFunctionMatch.handle(getWriteRequest()),
         type: "edge-function"
       };
     }
-    const functionMatch = await this.#functionsHandler?.match(matchRequest, destPath);
+    const functionMatch = await this.#functionsHandler?.match(readRequest, destPath);
     if (functionMatch) {
       if (functionMatch.preferStatic) {
-        const staticMatch2 = await this.#staticHandler?.match(matchRequest);
+        const staticMatch2 = await this.#staticHandler?.match(readRequest);
         if (staticMatch2) {
           const response = await staticMatch2.handle();
-          await this.#headersHandler?.apply(matchRequest, response, options.headersCollector);
+          await this.#headersHandler?.apply(readRequest, response, options.headersCollector);
           return { response, type: "static" };
         }
       }
-      return { response: await functionMatch.handle(getHandleRequest()), type: "function" };
+      return { response: await functionMatch.handle(getWriteRequest()), type: "function" };
     }
-    const redirectMatch = await this.#redirectsHandler?.match(matchRequest);
+    const redirectMatch = await this.#redirectsHandler?.match(readRequest);
     if (redirectMatch) {
       const functionMatch2 = await this.#functionsHandler?.match(new Request(redirectMatch.target), destPath);
       if (functionMatch2 && !functionMatch2.preferStatic) {
         return {
-          response: await functionMatch2.handle(getHandleRequest()),
+          response: await functionMatch2.handle(getWriteRequest()),
           type: "function"
         };
       }
       const response = await this.#redirectsHandler?.handle(
-        getHandleRequest(),
+        getWriteRequest(),
         redirectMatch,
         async (maybeStaticFile) => {
           const staticMatch2 = await this.#staticHandler?.match(maybeStaticFile);
@@ -359,17 +379,17 @@ var NetlifyDev = class {
         return { response, type: "redirect" };
       }
     }
-    const { pathname } = new URL(matchRequest.url);
+    const { pathname } = new URL(readRequest.url);
     if (pathname.startsWith("/.netlify/images")) {
       this.#logger.error(
-        "The Netlify Image CDN is currently only supported in the Netlify CLI. Run `npx netlify dev` to get started."
+        `The Netlify Image CDN is currently only supported in the Netlify CLI. Run ${netlifyCommand("npx netlify dev")} to get started.`
       );
       return;
     }
-    const staticMatch = await this.#staticHandler?.match(matchRequest);
+    const staticMatch = await this.#staticHandler?.match(readRequest);
     if (staticMatch) {
       const response = await staticMatch.handle();
-      await this.#headersHandler?.apply(matchRequest, response, options.headersCollector);
+      await this.#headersHandler?.apply(readRequest, response, options.headersCollector);
       return { response, type: "static" };
     }
   }
@@ -390,10 +410,19 @@ var NetlifyDev = class {
     });
     return config;
   }
+  /**
+   * Runs a `Request` through the Netlify request chain. If there is a match,
+   * it returns the resulting `Response` object; if not, it returns `undefined`.
+   */
   async handle(request, options = {}) {
     const result = await this.handleAndIntrospect(request, options);
     return result?.response;
   }
+  /**
+   * Runs a `Request` through the Netlify request chain. If there is a match,
+   * it returns an object with the resulting `Response` object and information
+   * about the match; if not, it returns `undefined`.
+   */
   async handleAndIntrospect(request, options = {}) {
     await fs2.mkdir(this.#functionsServePath, { recursive: true });
     const destPath = await fs2.mkdtemp(path2.join(this.#functionsServePath, `_`));
@@ -409,6 +438,11 @@ var NetlifyDev = class {
       }
     }
   }
+  /**
+   * Runs a Node.js `IncomingMessage` through the Netlify request chain. If
+   * there is a match, it returns an object with the resulting `Response`
+   * object and information about the match; if not, it returns `undefined`.
+   */
   async handleAndIntrospectNodeRequest(request, options = {}) {
     await fs2.mkdir(this.#functionsServePath, { recursive: true });
     const destPath = await fs2.mkdtemp(path2.join(this.#functionsServePath, `_`));
@@ -532,6 +566,9 @@ var NetlifyDev = class {
   async stop() {
     await Promise.allSettled(this.#cleanupJobs.map((task) => task()));
   }
+  getEnabledFeatures() {
+    return Object.entries(this.#features).filter(([_, enabled]) => enabled).map(([feature]) => feature);
+  }
 };
 export {
   NetlifyDev

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/dev",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "description": "Emulation of the Netlify environment for local development",
   "type": "module",
   "engines": {
@@ -47,20 +47,20 @@
   "author": "Netlify Inc.",
   "devDependencies": {
     "@netlify/api": "^14.0.3",
-    "@netlify/types": "2.0.1",
+    "@netlify/types": "2.0.2",
     "tsup": "^8.0.0",
     "vitest": "^3.0.0"
   },
   "dependencies": {
-    "@netlify/blobs": "9.1.4",
+    "@netlify/blobs": "9.1.5",
     "@netlify/config": "^23.0.8",
-    "@netlify/dev-utils": "3.1.0",
-    "@netlify/edge-functions": "2.14.0",
-    "@netlify/functions": "4.1.1",
-    "@netlify/headers": "2.0.0",
-    "@netlify/redirects": "3.0.0",
-    "@netlify/runtime": "4.0.0",
-    "@netlify/static": "3.0.0",
+    "@netlify/dev-utils": "3.1.1",
+    "@netlify/edge-functions": "2.14.2",
+    "@netlify/functions": "4.1.2",
+    "@netlify/headers": "2.0.1",
+    "@netlify/redirects": "3.0.1",
+    "@netlify/runtime": "4.0.2",
+    "@netlify/static": "3.0.1",
     "ulid": "^3.0.0"
   }
 }