perf: faster helpers, hot hooks, resolvers and cache keys - #81

Performance pass over code that runs per service call or per result item. Every change was benchmarked against main and keeps the existing behavior, with one exception: the cache key fix described below.

Results

Node 24, microbenchmarks, ns per call:

Changes

helpers (5a0c2d5)

• pickPaths: a string without . or [ skips castPath. A nested path is resolved in one walk instead of three.
• omitPaths: top-level keys are skipped while copying instead of deleted afterwards, which kept the result out of V8's dictionary mode.
• isEqual: when both objects have the same keys in the same order, the per-key propertyIsEnumerable lookup is skipped.

hooks and resolvers (4852021)

• Resolvers: the property list is built in place (no concat/Set/spread), and the top level skips the status spreads.
• setData/setResult: from is read through the new internal getContextPath, which skips building context.toJSON() on every call. A test checks it against hasPath/getPath on toJSON() with a real context.
• checkRequired: walks each path once. The second walk only runs on failure, to choose the error message.
• iff/iffElse: hooks are combined once at creation instead of on every call.
• checkContext: matches inline instead of copying the options and building an isContext closure on every call.
• disallow: the isProvider predicate is built once.
• throwIf, transformData, transformResult, muteEvent, resolve: they only await an actual promise. Public return types stay Promise<void>.

cache (82aa68d)

• A miss is stored under the key it was looked up with, so the key is computed once per miss instead of twice.
• stringifyParams uses JSON.stringify when normalize confirms it prints exactly what safe-stable-stringify would. That excludes cycles, BigInts, class instances, toJSON keys, encoded symbol keys and integer-like keys. Primitive $in/$nin elements are sorted without safeStringify.
• Cache keys are unchanged. A fuzz run of 200k random params against the implementation on main found no differences, so existing entries in persistent caches stay valid.

Behavior changes

• cache stores entries under the lookup key. Before, a hook running after cache that changed params caused the entry to be stored under a different key, one that no identical call would ever look up. Covered by a new test.
• iffElse with an array argument now combines the hooks when it is created. Mutating that array afterwards no longer has an effect. iff already copied its hooks.

Not changed

• setResult with dispatch keeps the deep copy. With a shallow copy, context.dispatch and context.result would share objects. A later transformResult(..., { dispatch }) would then write into the caller's result.
• defineStash keeps both snapshots. They protect the stored params from the fetch's hooks, and each one sits next to a find against the database.
• createRelated and trigger are unchanged. They make service calls anyway, so a few saved microtasks would not matter there.

Verification

pnpm test passes: lint without new warnings, typecheck, 1993 tests, coverage at 98%.

🤖 Generated with Claude Code