refactor: use node hash

Author: pi0

package.json

@@ -77,7 +77,6 @@
     "hookable": "^6.1.1",
     "nf3": "^0.3.24",
     "ocache": "^0.3.0",
-    "ohash": "^2.0.12",
     "rolldown": "^1.2.6",
     "rou3": "^0.9.2",
     "srvx": "^1.0.0",

pnpm-lock.yaml

@@ -1,5 +1,5 @@
 import type { Nitro } from "nitro/types";
-import { hash } from "ohash";
+import { hash } from "../../utils/hash.ts";
 
 export default function plugins(nitro: Nitro) {
   return {
@@ -8,12 +8,10 @@ export default function plugins(nitro: Nitro) {
       const nitroPlugins = [...new Set(nitro.options.plugins)];
 
       return /* js */ `
-  ${nitroPlugins
-    .map((plugin) => /* js */ `import _${hash(plugin).replace(/-/g, "")} from "${plugin}";`)
-    .join("\n")}
+  ${nitroPlugins.map((plugin) => /* js */ `import _${hash(plugin)} from "${plugin}";`).join("\n")}
 
   export const plugins = [
-    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
+    ${nitroPlugins.map((plugin) => `_${hash(plugin)}`).join(",\n")}
   ]
       `;
     },

src/build/virtual/plugins.ts

@@ -6,7 +6,7 @@ import { join } from "pathe";
 import { runtimeDir } from "nitro/meta";
 import { addRoute, createRouter, findRoute, findAllRoutes } from "rou3";
 import { compileRouterToString } from "rou3/compiler";
-import { hash } from "ohash";
+import { hash } from "./utils/hash.ts";
 
 const isGlobalMiddleware = (h: NitroEventHandler) => !h.method && (!h.route || h.route === "/**");
 
@@ -122,7 +122,7 @@ export function initNitroRouting(nitro: Nitro) {
 }
 
 function handlerWithImportHash(h: NitroEventHandler) {
-  const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler).replace(/-/g, "").slice(0, 6);
+  const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler);
   return { ...h, _importHash: id };
 }
 
@@ -137,7 +137,15 @@ export interface Route<T = unknown> {
 export class Router<T> {
   _routes?: Route<T>[];
   _router?: RouterContext<T>;
-  _compiled?: Record<string, string>;
+  /**
+   * Cached output of {@link compileToString}, invalidated by {@link _update}.
+   *
+   * Only one result is cached: each Router instance must always be compiled with
+   * the same `opts`. Compiling one instance with differing `opts` would silently
+   * return the first result, since `opts` holds a `serialize` closure and is
+   * therefore not hashable into a cache key.
+   */
+  _compiled?: string;
   _baseURL: string;
 
   constructor(baseURL?: string) {
@@ -169,12 +177,10 @@ export class Router<T> {
   }
 
   compileToString(opts?: RouterCompilerOptions<T>) {
-    const key = opts ? hash(opts) : "";
-    this._compiled ||= {};
-    if (this._compiled[key]) {
-      return this._compiled[key];
+    if (this._compiled) {
+      return this._compiled;
     }
-    this._compiled[key] = compileRouterToString(this._router!, undefined, opts);
+    this._compiled = compileRouterToString(this._router!, undefined, opts);
 
     // TODO: Upstream to rou3 compiler
     const onlyWildcard =
@@ -190,11 +196,10 @@ export class Router<T> {
       const guardCode = base
         ? `if(p!==${JSON.stringify(base)}&&!p.startsWith(${JSON.stringify(base + "/")})){return ${opts?.matchAll ? "[]" : "undefined"};}`
         : "";
-      this._compiled[key] =
-        /* js */ `/* @__PURE__ */ (() => {const data=${data};return ((_m, p)=>{${guardCode}return ${retCode};})})()`;
+      this._compiled = /* js */ `/* @__PURE__ */ (() => {const data=${data};return ((_m, p)=>{${guardCode}return ${retCode};})})()`;
     }
 
-    return this._compiled[key];
+    return this._compiled;
   }
 
   match(method: string, path: string): undefined | T {

src/routing.ts

@@ -8,7 +8,7 @@ import { createCacheRuleHandler, type RuleHandler } from "h3/rules";
 import { defineCachedHandler } from "./cache.ts";
 
 // `/* @__PURE__ */` so an app that uses only non-cache rules (e.g. `headers`)
-// tree-shakes this out along with `ocache`/`ohash`.
+// tree-shakes this out along with `ocache`.
 export const cache: RuleHandler<"cache"> = /* @__PURE__ */ createCacheRuleHandler({
   defineCachedHandler,
   // Preserve Nitro's cache storage key convention (`nitro/route-rules`) so

src/runtime/internal/route-rule-handlers.ts

@@ -21,7 +21,6 @@ export const runtimeDependencies: string[] = [
   "rou3", // sub-dep of h3
   "hookable", // traced
   "ocache", // dep
-  "ohash", // traced
   "rendu", // traced
   "scule", // traced
   "srvx", // dep

src/runtime/meta.ts

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Stable hash used for generated identifiers and cache keys.
+ *
+ * Returns a hex digest (safe to embed in JS identifiers) truncated to `length`.
+ */
+export function hash(input: string, length = 16): string {
+  return createHash("sha256").update(input).digest("hex").slice(0, length);
+}