Wrap methods hook decorator

Q: Wrap methods hook decorator

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Easy > **How to read this doc:** the core, real requirement — that wrapping must be completely TRANSPARENT, with return values passed through unchanged and hooks firing at the exact right moments — was verified directly: a real, logged hook sequence around 2 different wrapped method calls, confirming both correct ordering and unchanged return values. ## 1. The problem, restated `withHooks(obj, { before, after })` returns a NEW object where every FUNCTION property on `obj` is wrapped so that `before(methodName, args)` fires immediately before the real call, and `after(methodName, args, result)` fires immediately after — while the wrapped method still behaves EXACTLY like the original in every other respect, including its real return value. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Non-function properties? | Left genuinely unto

The problem

Problem, as an interviewer would state it: "Write withHooks(obj, { before, after }) — wrap EVERY method on obj so that a before hook fires just before each call, and an after hook fires just after, WITHOUT altering the method's own real behavior or return value."

Examples:

Code

const wrapped = withHooks(calculator, { before: logCall, after: logResult });
wrapped.add(2, 3); // logs before, runs add(2,3) normally, logs after, returns 5 unchanged

Clarifying questions expected:

Should non-function properties on the object be left untouched, or is this only for methods?
Does the wrapped method need to preserve the original this binding when called?
Should this handle an async method's hooks firing correctly relative to when the promise actually settles, not just when it is initially called?

Code / implementation expected: Yes — real, direct proof that both hooks fire correctly around real method calls, with return values passed through completely unchanged.

js-coding
utility
algorithm

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Easy

How to read this doc: the core, real requirement — that wrapping must be completely TRANSPARENT, with return values passed through unchanged and hooks firing at the exact right moments — was verified directly: a real, logged hook sequence around 2 different wrapped method calls, confirming both correct ordering and unchanged return values.

1. The problem, restated

withHooks(obj, { before, after }) returns a NEW object where every FUNCTION property on obj is wrapped so that before(methodName, args) fires immediately before the real call, and after(methodName, args, result) fires immediately after — while the wrapped method still behaves EXACTLY like the original in every other respect, including its real return value.

2. Clarifying questions a strong candidate

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: before/after hooks fire correctly around every wrapped method call, with return values passed through completely unchanged