Which strategy best prevents state leakage in shared context objects across asynchronous hook chains?

Answer

The recommended pattern to isolate temporary state in the FeathersJS context object across asynchronous hook chains is to store that state in a Symbol‑keyed property (e.g., context[Symbol.for('myapp/hook-temp')] = value).

Confirmed facts

• Symbols are non‑enumerable and have a low probability of colliding with existing string keys on context.
• FeathersJS does not provide a built‑in mechanism to freeze or scope parts of the context object; treating it as mutable only for documented fields (params, data, result) is the safest baseline.
• Using a Symbol avoids accidental overwrites by unrelated hooks that only manipulate known properties.

Steps for this case

1. Define a private Symbol once per project (or per hook group):

   const HOOK_TEMP = Symbol.for('myapp/hook-temp');

2. In a before hook (or any hook that needs to set temporary data):

   async function setTemp(context) {
     context[HOOK_TEMP] = { userId: context.params.user.id, requestId: context.id };
     return context;
   }

3. In the corresponding after hook, read (and optionally clean up) the temporary value:

   async function useTemp(context) {
     const temp = context[HOOK_TEMP];
     // … use temp for logging, enrichment, etc.
     delete context[HOOK_TEMP]; // optional, prevents reuse
     return context;
   }

4. Ensure all hooks that need to share this temporary data agree on the same Symbol (document the naming convention in your codebase).

Missing diagnostic detail

Does your project already enforce a Symbol‑based naming convention for hook‑scoped state? If not, establishing one is required before applying the pattern above.

Verification (optional)

Create a test before hook that sets context[HOOK_TEMP] and an after hook that reads it; run the service under load (e.g., with autocannon) and confirm that the Symbol value does not appear in unrelated requests.