Add Jest configuration and update package.json dependencies

Author: pmunin

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "configurations": [
+  {
+    "name": "Jest file",
+    "type": "node",
+    "request": "launch",
+    "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/jest",
+    "args": [
+        "${fileBasenameNoExtension}",
+        "--runInBand",
+        "--watch",
+        "--coverage=false",
+        "--no-cache"
+    ],
+    "cwd": "${workspaceRoot}",
+    "console": "integratedTerminal",
+    "internalConsoleOptions": "openOnFirstSessionStart",
+    "sourceMaps": true,
+    "windows": {
+        "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+    }
+    }
+  ]
+}

jest.config.js

@@ -9,5 +9,6 @@ module.exports = {
   },
   setupFilesAfterEnv:[
     "./jest.setupFilesAfterEnv.ts"
-  ]
+  ],
+  testTimeout: 30000,
 };

package.json

@@ -14,6 +14,7 @@
     "jest-extended": "^4.0.2",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
     "typescript": "^5.4.5"
   },
   "keywords": [],

src/TryCatchFinallyHooks.ts

@@ -48,7 +48,7 @@ export class TryCatchFinallyHooksBuilder<THookContext extends {}, TDecoratorArgs
 
   private hooks:ITryCatchFinallyHook<any>[] = []
 
-  add<NewHookContext, NewArgs = DecoratorArgsOf<NewHookContext>>(hook: ITryCatchFinallyHook<NewHookContext>)
+  add<NewHookContext, NewArgs = DecoratorArgsOf<NewHookContext>>(hook: ITryCatchFinallyHook<THookContext & NewHookContext>)
   : TryCatchFinallyHooksBuilder<THookContext & NewHookContext, TDecoratorArgs & NewArgs>
   {
     this.hooks.push(hook);
@@ -75,8 +75,8 @@ export class TryCatchFinallyHooksBuilder<THookContext extends {}, TDecoratorArgs
     const afterHooksTry = this.afterHooksTry?.bind(this)
     return (func:any)=>{
       return createTryCatchFinally(func, {
-        onTry() {
-          const ctx = { args }
+        onTry(funcArgs) {
+          const ctx = { funcArgs, args }
           const bht = beforeHooksTry(ctx as any)
           const hooksRes = _this.forEachHook(hook=> hook.onTry( ctx as any))
           for (const hookRes of [...hooksRes]) {

src/callStack.ts

@@ -1,4 +1,4 @@
-import { callStack } from "../callStack";
+import { callStack } from "../node/callStack";
 import { logOnFinally } from "./logOnFinally";
 import { measureDuration } from "../measureDuration";
 import { TryCatchFinallyHooksBuilder, ContextOf } from "../TryCatchFinallyHooks";

src/example/tracker.ts

@@ -0,0 +1,157 @@
+import { TryCatchFinallyHooksBuilder } from "../TryCatchFinallyHooks"
+import { callStack } from './callStack'
+import { AsyncResource, AsyncLocalStorage } from 'node:async_hooks'
+
+function createTrack(log:any){
+  return new TryCatchFinallyHooksBuilder()
+  .add(callStack)
+  .add({
+    onTry(ctx) {
+      log("onTry",ctx.args.name)
+      return {
+        onFinally() {
+          log("onFinally",ctx.callstack.map(c=>c.args.name).join("/"))
+        },
+        onCatch() {
+          log("onCatch",ctx.callstack.map(c=>c.args.name).join("/"))
+        }
+      }
+    }
+  })
+}
+
+
+test("callstack", ()=>{
+  const log = jest.fn((...args:any[])=>console.log(...args))
+  const track = createTrack(log)
+
+  const myChildFunc = jest.fn(track.asFunctionWrapper({name:"MyChildFunc"})((a:number,b:number)=>{
+    return a+b
+  }))
+
+
+  const myParentFunc = jest.fn(track.asFunctionWrapper({name: 'MyParentFunc'})(()=>{
+    (new Array(10).fill(0).map((_,i)=>{
+     return myChildFunc(i,i*2)
+    }))
+  }))
+
+
+  myParentFunc()
+
+  expect(myChildFunc).toHaveBeenCalledTimes(10)
+
+  expect(log).toHaveBeenCalledTimes(22)
+  expect(log).toHaveBeenCalledWith("onTry", "MyParentFunc")
+  expect(log).toHaveBeenCalledWith("onTry", "MyParentFunc/MyChildFunc")
+})
+
+test("callstack async",async ()=>{
+  const log = jest.fn((...args:any[])=>console.log("async",...args))
+  const track = createTrack(log)
+
+  const asyncStr = new AsyncLocalStorage<any>()
+  asyncStr.enterWith(["root"])
+
+  const myChildFunc = jest.fn(track.asFunctionWrapper({name:"MyAsyncChildFunc"})(async (a:number,b:number)=>{
+    const path = [...asyncStr.getStore()||[]]
+    asyncStr.enterWith([...path,"child"])
+    await delay(Math.random()*1000)
+    asyncStr.enterWith(path)
+
+    return a+b
+  }))
+
+
+  const myParentFunc = jest.fn(track.asFunctionWrapper({name: 'MyAsyncParentFunc'})(()=>{
+    const path = [...asyncStr.getStore()||[]]
+    asyncStr.enterWith([...path,"parent"])
+    return Promise.allSettled(new Array(2).fill(0).map(async (_,i)=>{
+     await myChildFunc(i,i*2)
+    }))
+  }))
+
+
+  await myParentFunc()
+
+  expect(myChildFunc).toHaveBeenCalledTimes(10)
+
+  expect(log).toHaveBeenCalledTimes(22)
+  expect(log).toHaveBeenCalledWith("onTry", "MyAsyncParentFunc")
+  expect(log).toHaveBeenCalledWith("onTry", "MyAsyncParentFunc/MyAsyncChildFunc")
+})
+
+function delay(ms:number){return new Promise(r=>setTimeout(r,ms))}
+
+
+test('async hooks',async ()=>{
+  const callStack = new AsyncLocalStorage<{name:string}[]>()
+  callStack.enterWith([{name:"parent"}])
+  await delay(100)
+  expect(callStack.getStore()).toEqual([{name:"parent"}])
+  callStack.enterWith([{name:"parent"}, {name:'child'}])
+  await delay(100)
+  expect(callStack.getStore()).toEqual([{name:"parent"},{name:"child"}])
+  await delay(100)
+
+
+  async function myAsyncFunc(){
+    await delay(500)
+    expect(callStack.getStore()).toEqual([{name:"parent"},{name:"child"}])
+    callStack.enterWith([...callStack.getStore()!, {name:"myAsyncFunc"}])
+    await delay(1000)
+    expect(callStack.getStore()).toEqual([{name:"parent"},{name:"child"}, {name:"myAsyncFunc"}])
+  }
+
+  async function myAsyncFunc2(){
+    await delay(1000)
+    expect(callStack.getStore()).toEqual([{name:"parent"},{name:"child"}])
+    callStack.enterWith([...callStack.getStore()!, {name:"myAsyncFunc2"}])
+    await delay(1000)
+    expect(callStack.getStore()).toEqual([{name:"parent"},{name:"child"}, {name:"myAsyncFunc2"}])
+  }
+
+
+  await Promise.allSettled([myAsyncFunc(), myAsyncFunc2()])
+
+  expect(callStack.getStore()).toEqual([{name:"parent"},{name:"child"}])
+
+
+})
+
+test.only('async hooks array',async ()=>{
+  const callStack = new AsyncLocalStorage<string[]>()
+  callStack.enterWith(["parent"])
+  await delay(100)
+  expect(callStack.getStore()).toEqual(["parent"])
+  await delay(100)
+
+
+  const stack = {} as any
+  Error.captureStackTrace(stack)
+  console.log("stack",stack.stack)
+
+
+  async function myAsyncFunc(n: number){
+    const actionName = "myAsyncFunc"+n
+    //await delay(0)
+    const storeBeforeAwait = callStack.getStore()!
+    //expect(storeBeforeAwait).toEqual(["parent"])
+    callStack.enterWith([...storeBeforeAwait, actionName])
+    
+    await delay(Math.random()*1000)
+    
+    const storeAfterAwait = callStack.getStore()!
+    expect(storeAfterAwait).toEqual([...storeBeforeAwait,actionName])
+    const newStack = [...storeAfterAwait]
+    newStack.pop()
+    callStack.enterWith(newStack)
+  }
+
+
+  await Promise.all(new Array(2).fill(0).map((_,i)=>myAsyncFunc(i)))
+
+  expect(callStack.getStore()).toEqual(["parent"])
+
+
+})

src/node/callStack.test.ts

@@ -0,0 +1,20 @@
+import { ITryCatchFinallyHook } from "../TryCatchFinallyHooks";
+import {AsyncLocalStorage} from 'async_hooks'
+
+
+type CallstackContext = { args: { name: string; }; callstack: CallstackContext[]; };
+let globalCallstack: AsyncLocalStorage<CallstackContext[]> = new AsyncLocalStorage();
+export const callStack: ITryCatchFinallyHook<CallstackContext> = {
+  onTry(ctx) {
+    const prevCallstack = [...globalCallstack.getStore()||[]];
+
+    ctx.callstack = [...prevCallstack, ctx];
+    globalCallstack.enterWith(ctx.callstack);
+    return {
+      onFinally() {
+        globalCallstack.enterWith(prevCallstack);
+      },
+      lastInQueue: true
+    };
+  }
+};

src/node/callStack.ts

@@ -1,9 +1,10 @@
 export type FunctionContext<TFunc extends (...args: any[]) => any = (...args: any[]) => any> = {
+  funcArgs: Parameters<TFunc>
   outcome?: FunctionExecutionOutcome<TFunc>
 }
 
-export type FunctionInterceptors<TFunc extends (...args: any[]) => any = (...args:any[])=>any, TContext extends {} = {}> = {
-  onTry: () => {
+export type FunctionInterceptors<TFunc extends (this:any, ...args: any[]) => any = (...args:any[])=>any, TContext extends {} = {}> = {
+  onTry: (funcArgs:Parameters<TFunc>) => {
     context?: TContext
     onCatch?: (ctx: TContext & FunctionContext<TFunc>) => void
     onFinally?: (ctx: TContext & FunctionContext<TFunc>) => void  
@@ -17,22 +18,22 @@ export function createTryCatchFinally<TFunc extends (this:any, ...args: any[]) =
   interceptors: FunctionInterceptors<TFunc, TContext>
 ): TFunc {
   type Ctx = TContext & FunctionContext<TFunc>
-  return function (...args) {
+  return function (...funcArgs) {
     let isAsync = false
     let funcRes: ReturnType<TFunc>;
-    let ctx: Ctx = {} as any
+    let ctx: Ctx = { funcArgs } as any
     let tryRes: ReturnType<NonNullable<typeof interceptors.onTry>> = {} as any;
     let onCatch = 'onCatch' in interceptors ? interceptors.onCatch : undefined;
     let onFinally = 'onFinally' in interceptors ? interceptors.onFinally : undefined;
 
     try {
       if(interceptors.onTry)
-        tryRes = interceptors.onTry()
-      if(tryRes.context) ctx = tryRes.context
+        tryRes = interceptors.onTry(funcArgs as any)
+      if(tryRes.context) ctx = Object.assign(tryRes.context, ctx)
       if('onCatch' in tryRes) onCatch = tryRes.onCatch
       if('onFinally' in tryRes) onFinally = tryRes.onFinally
 
-      funcRes = fn.apply(this,args);
+      funcRes = fn.apply(this,funcArgs);
       isAsync = isPromise(funcRes);
       ctx.outcome = { type: 'success', result: funcRes as Awaited<ReturnType<TFunc>> };
       if (!isAsync) {