restructure files and folders

Author: pmunin

src/TryCatchFinallyHooks.ts

@@ -1,10 +1,10 @@
-import { FunctionContext, createTryCatchFinally, FunctionInterceptors } from "./tryCatchFinally";
+import { FunctionContext, createTryCatchFinally } from "./tryCatchFinally";
 
-export interface ITryCatchFinallyHook<TParentContext extends FunctionContext=FunctionContext, TrtReturnContext={}>{
-  onTry(ctx: TParentContext): void | {
+export interface ITryCatchFinallyHook<TParentContext=FunctionContext, TrtReturnContext={}>{
+  onTry(ctx: TParentContext & FunctionContext): void | {
     context?: TrtReturnContext
-    onCatch?(ctx:TParentContext&TrtReturnContext): void
-    onFinally?(ctx:TParentContext&TrtReturnContext): void
+    onCatch?(ctx:FunctionContext & TParentContext&TrtReturnContext): void
+    onFinally?(ctx:FunctionContext & TParentContext & TrtReturnContext): void
     /**
      * If true, the hook will be executed after all other hooks
      */
@@ -20,9 +20,14 @@ export class TryCatchFinallyHooksBuilder<FullHookContext extends FunctionContext
 {
   private hooks:ITryCatchFinallyHook[] = []
 
+  add<TryReturnContext={}>(onTry:ITryCatchFinallyHook<FullHookContext,TryReturnContext>['onTry']): TryCatchFinallyHooksBuilder<FullHookContext & TryReturnContext>
   add<THookContext extends {}, TryReturnContext extends {}={}>(hook: ITryCatchFinallyHook<FullHookContext & THookContext,TryReturnContext>)
   : TryCatchFinallyHooksBuilder<THookContext &FullHookContext & TryReturnContext>
+  add(hook:any):any
   {
+    if(hook instanceof Function)
+      return this.add(TryCatchFinallyHooksBuilder.createHook(hook) as any)
+
     this.hooks.push(hook);
     return this as any;
   }
@@ -33,12 +38,6 @@ export class TryCatchFinallyHooksBuilder<FullHookContext extends FunctionContext
       onTry
     } as any
   }
-
-  createAndAdd<TryReturnContext={}>(onTry:ITryCatchFinallyHook<FullHookContext,TryReturnContext>['onTry']): TryCatchFinallyHooksBuilder<FullHookContext & TryReturnContext>
-  {
-    this.add(TryCatchFinallyHooksBuilder.createHook(onTry) as any)
-    return this as any
-  }
 
   asFunctionWrapper(args?: DecoratorArgsOf<FullHookContext>): <TFunc extends (...args:any[])=>any>(func:TFunc)=>TFunc
   {

src/callStack.test.ts

@@ -1,6 +1,5 @@
 import { TryCatchFinallyHooksBuilder } from "./TryCatchFinallyHooks"
 import { callStack } from './callStack'
-import { AsyncResource, AsyncLocalStorage } from 'node:async_hooks'
 
 function createTrack(log:any){
   return new TryCatchFinallyHooksBuilder()
@@ -53,24 +52,16 @@ test("callstack async",async ()=>{
   const log = jest.fn()
   const track = createTrack(log)
 
-  const asyncStr = new AsyncLocalStorage<any>()
-  asyncStr.enterWith(["root"])
 
   const myChildFunc = jest.fn(track.asFunctionWrapper({name:"MyAsyncChildFunc"})(async function myChildFunc(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'})(async function myParentFunc(){
-    const path = [...asyncStr.getStore()||[]]
-    asyncStr.enterWith([...path,"parent"])
     return await Promise.allSettled(new Array(amountOfParallels).fill(0).map(async function promiseAllRunner(_,i){
-     await myChildFunc(i,i*2)
+      await myChildFunc(i,i*2)
     }))
   }))
 

src/callStack.ts

@@ -1,5 +1,4 @@
 import { ITryCatchFinallyHook, TryCatchFinallyHooksBuilder } from "./TryCatchFinallyHooks";
-import { FunctionContext } from "./tryCatchFinally";
 
 /**
  * This is a callstack tracker, which provides Stack of Called Function Context - works both for async and sync call stacks
@@ -32,8 +31,8 @@ export type CallStackContext = {
 };
 
 
-export const callStack = TryCatchFinallyHooksBuilder.createHook<CallStackContext>(
-  (ctx)=>{
+export const callStack: ITryCatchFinallyHook<CallStackContext>= {
+  onTry(ctx){
     if(!ctx.name)
       ctx.name = ctx.args.name || ctx.func.name || '<anonymous>'
 
@@ -58,7 +57,7 @@ export const callStack = TryCatchFinallyHooksBuilder.createHook<CallStackContext
       lastInQueue: true
     };
   }
-)
+}
 
 /**
  * Returns current tracked callstack. Filters Error.captureStackTrace by tracked functions.

src/defer.ts

@@ -0,0 +1,22 @@
+import { ITryCatchFinallyHook } from "./TryCatchFinallyHooks";
+import { FunctionContext } from "./tryCatchFinally";
+
+export type DeferContext = {
+  defer: (fnToDefer: (ctx: DeferContext) => void) => void
+}
+
+export const Defer: ITryCatchFinallyHook<DeferContext> = {
+  onTry(ctx){
+    const funcsToDefer = [] as ((ctx:DeferContext)=>void)[]
+    ctx.defer = (fnToDefer) => {
+      funcsToDefer.push(fnToDefer)
+    }
+    return {
+      onFinally() {
+        for (const defer of funcsToDefer) {
+          defer(ctx);
+        }
+      }
+    }
+  }
+}

src/example/logOnFinally.ts

@@ -1 +1,5 @@
-export * from './tryCatchFinally'
+export * from './tryCatchFinally'
+export * from './TryCatchFinallyHooks'
+export * from './defer'
+export * from './measureDuration'
+export * from './callStack'

src/example/tracker.test.ts

@@ -0,0 +1,31 @@
+import { TryCatchFinallyHooksBuilder } from "./TryCatchFinallyHooks";
+import { measureDuration } from "./measureDuration";
+
+test("measure duration", async() => {
+  const actualDuration = 500;
+
+  const track = new TryCatchFinallyHooksBuilder()
+    .add(measureDuration)
+    //test
+    .add(ctx=>{
+      return {
+        onFinally() {
+          expect(ctx.duration).toBeGreaterThanOrEqual(actualDuration)
+        }
+      }
+    })
+  ;
+  const myTrackedFunction = track.asFunctionWrapper({ name: 'MyAction' })(
+    async function myFunction(a: number, b: number) {
+      await delay(actualDuration);
+      return a + b;
+    }
+  );
+
+  const res = await myTrackedFunction(1, 2);
+  expect(res).toBe(3);
+})
+
+async function delay(ms: number) {
+  return new Promise<void>(resolve => setTimeout(resolve, ms));
+}

src/index.ts

@@ -1,21 +1,32 @@
 import { callStack } from "../callStack";
-import { logOnFinally } from "./logOnFinally";
 import { measureDuration } from "../measureDuration";
-import { TryCatchFinallyHooksBuilder, ContextOf } from "../TryCatchFinallyHooks";
+import { TryCatchFinallyHooksBuilder, ITryCatchFinallyHook } from "../TryCatchFinallyHooks";
+
+
+export const logOnFinally: ITryCatchFinallyHook<{ args: { name?: string; }; name:string }> = {
+  onTry(ctx){
+  if(!ctx.name) ctx.name = ctx.args.name || ctx.func.name || '<anonymous>'
+  return {
+    onFinally() {
+      console.log(`Function ${ctx.args.name} finished!`);
+    },
+  };
+}};
+
 
 const track = new TryCatchFinallyHooksBuilder()
   .add(callStack)
   .add(measureDuration)
   .add(logOnFinally)
-  .createAndAdd(ctx => {
+  .add(ctx => {
     return {
       onFinally() {
         const datadog: any = {};
         datadog.histogram(`action-${ctx.args.name}-duration`, ctx.duration, { tags: ['action:' + ctx.name, 'callstack:' + ctx.getCallStack().map(c => c.name).join('/')] });
       },
     };
   })
-  .createAndAdd((ctx) => {
+  .add((ctx) => {
     type DeferContext = typeof ctx
     const funcsToDefer = [] as ((_ctx:DeferContext) => void)[]
     return {
@@ -46,3 +57,5 @@ const myTrackedFunction = track.asFunctionWrapper({ name: 'MyAction' })(
     return res;
   }
 );
+
+test.todo("combined tests")