nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

package/dist/runtime/internal/route-rules.mjs

@@ -1,62 +1,64 @@
 import { proxyRequest, redirect as sendRedirect } from "h3";
 import { joinURL, withQuery, withoutBase } from "ufo";
 import { defineCachedEventHandler } from "./cache.mjs";
+// Headers route rule
 export const headers = ((m) => function headersRouteRule(event) {
-  for (const [key, value] of Object.entries(m.options || {})) {
-    event.res.headers.set(key, value);
-  }
+	for (const [key, value] of Object.entries(m.options || {})) {
+		event.res.headers.set(key, value);
+	}
 });
+// Redirect route rule
 export const redirect = ((m) => function redirectRouteRule(event) {
-  let target = m.options?.to;
-  if (!target) {
-    return;
-  }
-  if (target.endsWith("/**")) {
-    let targetPath = event.url.pathname + event.url.search;
-    const strpBase = m.options._redirectStripBase;
-    if (strpBase) {
-      targetPath = withoutBase(targetPath, strpBase);
-    }
-    target = joinURL(target.slice(0, -3), targetPath);
-  } else if (event.url.search) {
-    target = withQuery(target, Object.fromEntries(event.url.searchParams));
-  }
-  return sendRedirect(target, m.options?.status);
+	let target = m.options?.to;
+	if (!target) {
+		return;
+	}
+	if (target.endsWith("/**")) {
+		let targetPath = event.url.pathname + event.url.search;
+		const strpBase = m.options._redirectStripBase;
+		if (strpBase) {
+			targetPath = withoutBase(targetPath, strpBase);
+		}
+		target = joinURL(target.slice(0, -3), targetPath);
+	} else if (event.url.search) {
+		target = withQuery(target, Object.fromEntries(event.url.searchParams));
+	}
+	return sendRedirect(target, m.options?.status);
 });
+// Proxy route rule
 export const proxy = ((m) => function proxyRouteRule(event) {
-  let target = m.options?.to;
-  if (!target) {
-    return;
-  }
-  if (target.endsWith("/**")) {
-    let targetPath = event.url.pathname + event.url.search;
-    const strpBase = m.options._proxyStripBase;
-    if (strpBase) {
-      targetPath = withoutBase(targetPath, strpBase);
-    }
-    target = joinURL(target.slice(0, -3), targetPath);
-  } else if (event.url.search) {
-    target = withQuery(target, Object.fromEntries(event.url.searchParams));
-  }
-  return proxyRequest(event, target, {
-    ...m.options
-  });
+	let target = m.options?.to;
+	if (!target) {
+		return;
+	}
+	if (target.endsWith("/**")) {
+		let targetPath = event.url.pathname + event.url.search;
+		const strpBase = m.options._proxyStripBase;
+		if (strpBase) {
+			targetPath = withoutBase(targetPath, strpBase);
+		}
+		target = joinURL(target.slice(0, -3), targetPath);
+	} else if (event.url.search) {
+		target = withQuery(target, Object.fromEntries(event.url.searchParams));
+	}
+	return proxyRequest(event, target, { ...m.options });
 });
+// Cache route rule
 export const cache = ((m) => function cacheRouteRule(event, next) {
-  if (!event.context.matchedRoute) {
-    return next();
-  }
-  const cachedHandlers = globalThis.__nitroCachedHandlers ??= /* @__PURE__ */ new Map();
-  const { handler, route } = event.context.matchedRoute;
-  const key = `${m.route}:${route}`;
-  let cachedHandler = cachedHandlers.get(key);
-  if (!cachedHandler) {
-    cachedHandler = defineCachedEventHandler(handler, {
-      group: "nitro/route-rules",
-      name: key,
-      ...m.options
-    });
-    cachedHandlers.set(key, cachedHandler);
-  }
-  return cachedHandler(event);
+	if (!event.context.matchedRoute) {
+		return next();
+	}
+	const cachedHandlers = globalThis.__nitroCachedHandlers ??= new Map();
+	const { handler, route } = event.context.matchedRoute;
+	const key = `${m.route}:${route}`;
+	let cachedHandler = cachedHandlers.get(key);
+	if (!cachedHandler) {
+		cachedHandler = defineCachedEventHandler(handler, {
+			group: "nitro/route-rules",
+			name: key,
+			...m.options
+		});
+		cachedHandlers.set(key, cachedHandler);
+	}
+	return cachedHandler(event);
 });

package/dist/runtime/internal/routes/dev-tasks.d.mts

@@ -1,31 +1,2 @@
-declare const _default: {
-    "~rou3": import("h3").RouterContext;
-    request(request: import("srvx").ServerRequest | URL | string, options?: RequestInit, context?: import("h3").H3EventContext): Response | Promise<Response>;
-    use(route: string, handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
-    use(handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
-    on(method: import("h3").HTTPMethod | Lowercase<import("h3").HTTPMethod> | "", route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    register(plugin: import("h3").H3Plugin): /*elided*/ any;
-    mount(base: string, input: import("srvx").FetchHandler | {
-        fetch: import("srvx").FetchHandler;
-    } | /*elided*/ any): /*elided*/ any;
-    all(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    get(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    post(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    put(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    delete(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    patch(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    head(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    options(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    connect(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    trace(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
-    readonly config: import("h3").H3Config;
-    "~middleware": import("h3").Middleware[];
-    "~routes": import("h3").H3Route[];
-    fetch(_request: import("srvx").ServerRequest): Response | Promise<Response>;
-    handler(event: import("h3").H3Event): unknown | Promise<unknown>;
-    "~request"(request: import("srvx").ServerRequest, context?: import("h3").H3EventContext): Response | Promise<Response>;
-    "~findRoute"(_event: import("h3").H3Event): import("h3").MatchedRoute<import("h3").H3Route> | void;
-    "~getMiddleware"(event: import("h3").H3Event, route: import("h3").MatchedRoute<import("h3").H3Route> | undefined): import("h3").Middleware[];
-    "~addRoute"(_route: import("h3").H3Route): void;
-};
+declare const _default;
 export default _default;

package/dist/runtime/internal/routes/dev-tasks.mjs

@@ -2,22 +2,20 @@ import { H3 } from "h3";
 import { runTask } from "nitro/runtime";
 import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
 export default new H3().get("/_nitro/tasks", async () => {
-  const _tasks = await Promise.all(
-    Object.entries(tasks).map(async ([name, task]) => {
-      const _task = await task.resolve?.();
-      return [name, { description: _task?.meta?.description }];
-    })
-  );
-  return {
-    tasks: Object.fromEntries(_tasks),
-    scheduledTasks
-  };
+	const _tasks = await Promise.all(Object.entries(tasks).map(async ([name, task]) => {
+		const _task = await task.resolve?.();
+		return [name, { description: _task?.meta?.description }];
+	}));
+	return {
+		tasks: Object.fromEntries(_tasks),
+		scheduledTasks
+	};
 }).get("/_nitro/tasks/:name", async (event) => {
-  const name = event.context.params?.name;
-  const body = await event.req.json().catch(() => ({}));
-  const payload = {
-    ...Object.fromEntries(event.url.searchParams.entries()),
-    ...body
-  };
-  return await runTask(name, { payload });
+	const name = event.context.params?.name;
+	const body = await event.req.json().catch(() => ({}));
+	const payload = {
+		...Object.fromEntries(event.url.searchParams.entries()),
+		...body
+	};
+	return await runTask(name, { payload });
 });

package/dist/runtime/internal/routes/openapi.d.mts

@@ -1,3 +1,4 @@
 import type { EventHandler } from "h3";
+// Served as /_openapi.json
 declare const _default: EventHandler;
 export default _default;

package/dist/runtime/internal/routes/openapi.mjs

@@ -3,98 +3,92 @@ import { joinURL } from "ufo";
 import { defu } from "defu";
 import { handlersMeta } from "#nitro-internal-virtual/routing-meta";
 import { useRuntimeConfig } from "../runtime-config.mjs";
+// Served as /_openapi.json
 export default defineHandler((event) => {
-  const runtimeConfig = useRuntimeConfig();
-  const base = runtimeConfig.app?.baseURL;
-  const url = joinURL(getRequestURL(event).origin, base);
-  const meta = {
-    title: "Nitro Server Routes",
-    ...runtimeConfig.nitro?.openAPI?.meta
-  };
-  const {
-    paths,
-    globals: { components, ...globalsRest }
-  } = getHandlersMeta();
-  const extensible = Object.fromEntries(
-    Object.entries(globalsRest).filter(([key]) => key.startsWith("x-"))
-  );
-  return {
-    openapi: "3.1.0",
-    info: {
-      title: meta?.title,
-      version: meta?.version,
-      description: meta?.description
-    },
-    servers: [
-      {
-        url,
-        description: "Local Development Server",
-        variables: {}
-      }
-    ],
-    paths,
-    components,
-    ...extensible
-  };
+	const runtimeConfig = useRuntimeConfig();
+	const base = runtimeConfig.app?.baseURL;
+	const url = joinURL(getRequestURL(event).origin, base);
+	const meta = {
+		title: "Nitro Server Routes",
+		...runtimeConfig.nitro?.openAPI?.meta
+	};
+	const { paths, globals: { components,...globalsRest } } = getHandlersMeta();
+	const extensible = Object.fromEntries(Object.entries(globalsRest).filter(([key]) => key.startsWith("x-")));
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: meta?.title,
+			version: meta?.version || "1.0.0",
+			description: meta?.description
+		},
+		servers: [{
+			url,
+			description: "Local Development Server",
+			variables: {}
+		}],
+		paths,
+		components,
+		...extensible
+	};
 });
 function getHandlersMeta() {
-  const paths = {};
-  let globals = {};
-  for (const h of handlersMeta) {
-    const { route, parameters } = normalizeRoute(h.route || "");
-    const tags = defaultTags(h.route || "");
-    const method = (h.method || "get").toLowerCase();
-    const { $global, ...openAPI } = h.meta?.openAPI || {};
-    const item = {
-      [method]: {
-        tags,
-        parameters,
-        responses: {
-          200: { description: "OK" }
-        },
-        ...openAPI
-      }
-    };
-    if ($global) {
-      globals = defu($global, globals);
-    }
-    if (paths[route] === void 0) {
-      paths[route] = item;
-    } else {
-      Object.assign(paths[route], item);
-    }
-  }
-  return { paths, globals };
+	const paths = {};
+	let globals = {};
+	for (const h of handlersMeta) {
+		const { route, parameters } = normalizeRoute(h.route || "");
+		const tags = defaultTags(h.route || "");
+		const method = (h.method || "get").toLowerCase();
+		const { $global,...openAPI } = h.meta?.openAPI || {};
+		const item = { [method]: {
+			tags,
+			parameters,
+			responses: { 200: { description: "OK" } },
+			...openAPI
+		} };
+		if ($global) {
+			// TODO: Warn on conflicting global definitions?
+			globals = defu($global, globals);
+		}
+		if (paths[route] === undefined) {
+			paths[route] = item;
+		} else {
+			Object.assign(paths[route], item);
+		}
+	}
+	return {
+		paths,
+		globals
+	};
 }
 function normalizeRoute(_route) {
-  const parameters = [];
-  let anonymousCtr = 0;
-  const route = _route.replace(/:(\w+)/g, (_, name) => `{${name}}`).replace(/\/(\*)\//g, () => `/{param${++anonymousCtr}}/`).replace(/\*\*{/, "{").replace(/\/(\*\*)$/g, () => `/{*param${++anonymousCtr}}`);
-  const paramMatches = route.matchAll(/{(\*?\w+)}/g);
-  for (const match of paramMatches) {
-    const name = match[1];
-    if (!parameters.some((p) => p.name === name)) {
-      parameters.push({
-        name,
-        in: "path",
-        required: true,
-        schema: { type: "string" }
-      });
-    }
-  }
-  return {
-    route,
-    parameters
-  };
+	const parameters = [];
+	let anonymousCtr = 0;
+	const route = _route.replace(/:(\w+)/g, (_, name) => `{${name}}`).replace(/\/(\*)\//g, () => `/{param${++anonymousCtr}}/`).replace(/\*\*{/, "{").replace(/\/(\*\*)$/g, () => `/{*param${++anonymousCtr}}`);
+	const paramMatches = route.matchAll(/{(\*?\w+)}/g);
+	for (const match of paramMatches) {
+		const name = match[1];
+		if (!parameters.some((p) => p.name === name)) {
+			parameters.push({
+				name,
+				in: "path",
+				required: true,
+				schema: { type: "string" }
+			});
+		}
+	}
+	return {
+		route,
+		parameters
+	};
 }
 function defaultTags(route) {
-  const tags = [];
-  if (route.startsWith("/api/")) {
-    tags.push("API Routes");
-  } else if (route.startsWith("/_")) {
-    tags.push("Internal");
-  } else {
-    tags.push("App Routes");
-  }
-  return tags;
+	const tags = [];
+	if (route.startsWith("/api/")) {
+		tags.push("API Routes");
+	} else if (route.startsWith("/_")) {
+		tags.push("Internal");
+	} else {
+		tags.push("App Routes");
+	}
+	return tags;
 }

package/dist/runtime/internal/routes/renderer-template.d.mts

@@ -1,2 +1,2 @@
 import type { H3Event } from "h3";
-export default function renderIndexHTML(event: H3Event): any;
+export default function renderIndexHTML(event: H3Event);

package/dist/runtime/internal/routes/renderer-template.dev.d.mts

@@ -1,3 +1,2 @@
 import type { H3Event } from "h3";
-import { HTTPResponse } from "h3";
-export default function renderIndexHTML(event: H3Event): Promise<Response | HTTPResponse>;
+export default function renderIndexHTML(event: H3Event);

package/dist/runtime/internal/routes/renderer-template.dev.mjs

@@ -1,21 +1,14 @@
-import {
-  rendererTemplate,
-  rendererTemplateFile
-} from "#nitro-internal-virtual/renderer-template";
+import { rendererTemplate, rendererTemplateFile } from "#nitro-internal-virtual/renderer-template";
 import { HTTPResponse } from "h3";
 import { hasTemplateSyntax, renderToResponse, compileTemplate } from "rendu";
 export default async function renderIndexHTML(event) {
-  let html = await rendererTemplate(event.req);
-  if (globalThis.__transform_html__) {
-    html = await globalThis.__transform_html__(html);
-  }
-  if (!hasTemplateSyntax(html)) {
-    return new HTTPResponse(html, {
-      headers: { "content-type": "text/html; charset=utf-8" }
-    });
-  }
-  const template = compileTemplate(html, { filename: rendererTemplateFile });
-  return renderToResponse(template, {
-    request: event.req
-  });
+	let html = await rendererTemplate(event.req);
+	if (globalThis.__transform_html__) {
+		html = await globalThis.__transform_html__(html);
+	}
+	if (!hasTemplateSyntax(html)) {
+		return new HTTPResponse(html, { headers: { "content-type": "text/html; charset=utf-8" } });
+	}
+	const template = compileTemplate(html, { filename: rendererTemplateFile });
+	return renderToResponse(template, { request: event.req });
 }

package/dist/runtime/internal/routes/renderer-template.mjs

@@ -1,4 +1,4 @@
 import { rendererTemplate } from "#nitro-internal-virtual/renderer-template";
 export default function renderIndexHTML(event) {
-  return rendererTemplate(event.req);
+	return rendererTemplate(event.req);
 }

package/dist/runtime/internal/routes/scalar.d.mts

@@ -1,3 +1,4 @@
 import { type EventHandler } from "h3";
+// Served as /_scalar
 declare const _default: EventHandler;
 export default _default;

package/dist/runtime/internal/routes/scalar.mjs

@@ -1,21 +1,24 @@
 import { defineHandler } from "h3";
 import { useRuntimeConfig } from "../runtime-config.mjs";
+// Served as /_scalar
 export default defineHandler((event) => {
-  const runtimeConfig = useRuntimeConfig();
-  const title = runtimeConfig.nitro.openAPI?.meta?.title || "API Reference";
-  const description = runtimeConfig.nitro.openAPI?.meta?.description || "";
-  const openAPIEndpoint = runtimeConfig.nitro.openAPI?.route || "./_openapi.json";
-  const _config = runtimeConfig.nitro.openAPI?.ui?.scalar;
-  const scalarConfig = {
-    ..._config,
-    url: openAPIEndpoint,
-    // @ts-expect-error (missing types?)
-    spec: { url: openAPIEndpoint, ..._config?.spec }
-  };
-  event.res.headers.set("Content-Type", "text/html");
-  return (
-    /* html */
-    `<!doctype html>
+	const runtimeConfig = useRuntimeConfig();
+	const title = runtimeConfig.nitro.openAPI?.meta?.title || "API Reference";
+	const description = runtimeConfig.nitro.openAPI?.meta?.description || "";
+	const openAPIEndpoint = runtimeConfig.nitro.openAPI?.route || "./_openapi.json";
+	// https://github.com/scalar/scalar
+	const _config = runtimeConfig.nitro.openAPI?.ui?.scalar;
+	const scalarConfig = {
+		..._config,
+		url: openAPIEndpoint,
+		spec: {
+			url: openAPIEndpoint,
+			..._config?.spec
+		}
+	};
+	// The default page title
+	event.res.headers.set("Content-Type", "text/html");
+	return `<!doctype html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
@@ -29,16 +32,13 @@ export default defineHandler((event) => {
       <body>
         <script
           id="api-reference"
-          data-configuration="${JSON.stringify(scalarConfig).split('"').join("&quot;")}"
+          data-configuration="${JSON.stringify(scalarConfig).split("\"").join("&quot;")}"
         ><\/script>
         <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
       </body>
-    </html>`
-  );
+    </html>`;
 });
-const customTheme = (
-  /* css */
-  `/* basic theme */
+const customTheme = `/* basic theme */
   .light-mode,
   .light-mode .dark-mode {
     --theme-background-1: #fff;
@@ -190,5 +190,4 @@ const customTheme = (
   }
   .section-container:nth-of-type(2) {
     overflow: hidden;
-  }`
-);
+  }`;

package/dist/runtime/internal/routes/swagger.d.mts

@@ -1,3 +1,4 @@
 import type { EventHandler } from "h3";
+// https://github.com/swagger-api/swagger-ui
 declare const _default: EventHandler;
 export default _default;

package/dist/runtime/internal/routes/swagger.mjs

@@ -1,15 +1,14 @@
 import { defineHandler } from "h3";
 import { useRuntimeConfig } from "../runtime-config.mjs";
+// https://github.com/swagger-api/swagger-ui
 export default defineHandler((event) => {
-  const runtimeConfig = useRuntimeConfig();
-  const title = runtimeConfig.nitro.openAPI?.meta?.title || "API Reference";
-  const description = runtimeConfig.nitro.openAPI?.meta?.description || "";
-  const openAPIEndpoint = runtimeConfig.nitro.openAPI?.route || "./_openapi.json";
-  const CDN_BASE = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@^5";
-  event.res.headers.set("Content-Type", "text/html");
-  return (
-    /* html */
-    `<!doctype html>
+	const runtimeConfig = useRuntimeConfig();
+	const title = runtimeConfig.nitro.openAPI?.meta?.title || "API Reference";
+	const description = runtimeConfig.nitro.openAPI?.meta?.description || "";
+	const openAPIEndpoint = runtimeConfig.nitro.openAPI?.route || "./_openapi.json";
+	const CDN_BASE = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@^5";
+	event.res.headers.set("Content-Type", "text/html");
+	return `<!doctype html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
@@ -39,6 +38,5 @@ export default defineHandler((event) => {
           };
         <\/script>
       </body>
-    </html> `
-  );
+    </html> `;
 });

package/dist/runtime/internal/runtime-config.d.mts

@@ -1,9 +1,9 @@
 import type { NitroRuntimeConfig } from "nitro/types";
 export declare function useRuntimeConfig(): NitroRuntimeConfig;
 type EnvOptions = {
-    prefix?: string;
-    altPrefix?: string;
-    envExpansion?: boolean;
+	prefix?: string;
+	altPrefix?: string;
+	envExpansion?: boolean;
 };
-export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string): Record<string, any>;
+export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string);
 export {};

package/dist/runtime/internal/runtime-config.mjs

@@ -1,49 +1,54 @@
 import { snakeCase } from "scule";
 export function useRuntimeConfig() {
-  return useRuntimeConfig._cached ||= getRuntimeConfig();
+	return useRuntimeConfig._cached ||= getRuntimeConfig();
 }
 function getRuntimeConfig() {
-  const runtimeConfig = globalThis.__NITRO_RUNTIME_CONFIG__ || process.env.RUNTIME_CONFIG || {};
-  const env = globalThis.process?.env || {};
-  applyEnv(runtimeConfig, {
-    prefix: "NITRO_",
-    altPrefix: runtimeConfig.nitro?.envPrefix ?? env?.NITRO_ENV_PREFIX ?? "_",
-    envExpansion: runtimeConfig.nitro?.envExpansion ?? env?.NITRO_ENV_EXPANSION ?? false
-  });
-  return runtimeConfig;
+	const runtimeConfig = globalThis.__NITRO_RUNTIME_CONFIG__ || process.env.RUNTIME_CONFIG || {};
+	const env = globalThis.process?.env || {};
+	applyEnv(runtimeConfig, {
+		prefix: "NITRO_",
+		altPrefix: runtimeConfig.nitro?.envPrefix ?? env?.NITRO_ENV_PREFIX ?? "_",
+		envExpansion: runtimeConfig.nitro?.envExpansion ?? env?.NITRO_ENV_EXPANSION ?? false
+	});
+	return runtimeConfig;
 }
 function getEnv(key, opts) {
-  const envKey = snakeCase(key).toUpperCase();
-  return process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey];
+	const envKey = snakeCase(key).toUpperCase();
+	return process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey];
 }
 function _isObject(input) {
-  return typeof input === "object" && !Array.isArray(input);
+	return typeof input === "object" && !Array.isArray(input);
 }
 export function applyEnv(obj, opts, parentKey = "") {
-  for (const key in obj) {
-    const subKey = parentKey ? `${parentKey}_${key}` : key;
-    const envValue = getEnv(subKey, opts);
-    if (_isObject(obj[key])) {
-      if (_isObject(envValue)) {
-        obj[key] = { ...obj[key], ...envValue };
-        applyEnv(obj[key], opts, subKey);
-      } else if (envValue === void 0) {
-        applyEnv(obj[key], opts, subKey);
-      } else {
-        obj[key] = envValue ?? obj[key];
-      }
-    } else {
-      obj[key] = envValue ?? obj[key];
-    }
-    if (opts.envExpansion && typeof obj[key] === "string") {
-      obj[key] = _expandFromEnv(obj[key]);
-    }
-  }
-  return obj;
+	for (const key in obj) {
+		const subKey = parentKey ? `${parentKey}_${key}` : key;
+		const envValue = getEnv(subKey, opts);
+		if (_isObject(obj[key])) {
+			// Same as before
+			if (_isObject(envValue)) {
+				obj[key] = {
+					...obj[key],
+					...envValue
+				};
+				applyEnv(obj[key], opts, subKey);
+			} else if (envValue === undefined) {
+				applyEnv(obj[key], opts, subKey);
+			} else {
+				obj[key] = envValue ?? obj[key];
+			}
+		} else {
+			obj[key] = envValue ?? obj[key];
+		}
+		// Experimental env expansion
+		if (opts.envExpansion && typeof obj[key] === "string") {
+			obj[key] = _expandFromEnv(obj[key]);
+		}
+	}
+	return obj;
 }
 const envExpandRx = /\{\{([^{}]*)\}\}/g;
 function _expandFromEnv(value) {
-  return value.replace(envExpandRx, (match, key) => {
-    return process.env[key] || match;
-  });
+	return value.replace(envExpandRx, (match, key) => {
+		return process.env[key] || match;
+	});
 }