refactoring

Author: pmunin

readme.md

@@ -21,7 +21,7 @@ It supports sync and async functions/methods
 
 ```ts
 /// track.ts
-export const tracker = new TryCatchFinallyHooksBuilder()
+export const hooks = new Hooks()
   .add(callStack)
   .add(measureDuration)
   .add(ctx => {
@@ -44,13 +44,12 @@ export const tracker = new TryCatchFinallyHooksBuilder()
     };
   })
 
-export const trackFn = tracker.asFunctionWrapper.bind(tracker)
-export const trackMethod = tracker.asDecorator.bind(tracker)
-
+export const track = hooks.create()
 // myClass.ts
 
 class MyClass{
-  @trackMethod({name:'Hello world'})
+  @track({name:'Hello world'})
+  //@hooks.decor({name:'Hello world'}) //alternative
   async helloWorld(url:string)
   {
     await doing()
@@ -61,11 +60,13 @@ class MyClass{
 
 // myFunc.ts
 
-export const myFunc = trackFn({name: 'My function'})((param1:number)=>{
+
+export const myFunc = track({name: 'My function'}, (param1:number)=>{   //alternative: myFunc = hooks.wrap({name:'Hello world'}, (param1...)=>{...})
+
     // doing something long running and risky
   step1()
   step2()
-  const res = tracker.scope({name:'important step 3'},()=>{
+  const res = track.scope({name:'important step 3'},()=>{
     return step3(param1)
   })
   return res

specs/combine-hooks.spec.ts

@@ -1,6 +1,7 @@
 import { callStack } from "@/callStack";
 import { measureDuration } from "@/measureDuration";
-import { TryCatchFinallyHooksBuilder, ITryCatchFinallyHook } from "@/TryCatchFinallyHooks";
+import { ITryCatchFinallyHook } from "@/TryCatchFinallyHook";
+import { Hooks } from "@/Hooks";
 
 
 export const logOnFinally: ITryCatchFinallyHook<{ args: { name?: string; }; name:string }> = {
@@ -14,7 +15,7 @@ export const logOnFinally: ITryCatchFinallyHook<{ args: { name?: string; }; name
 }};
 
 
-const track = new TryCatchFinallyHooksBuilder()
+const track = new Hooks()
   .add(callStack)
   .add(measureDuration)
   .add(logOnFinally)
@@ -41,16 +42,16 @@ const track = new TryCatchFinallyHooksBuilder()
         }
       }
     }
-  })
+  }).create()
 ;
-const myTrackedFunction = track.asFunctionWrapper({ name: 'MyAction' })(
+const myTrackedFunction = track({ name: 'MyAction' },
   function myTrackedFunction(a: number, b: number) {
-    track.current!.defer((op) => {
+    track.hooks.context!.defer((op) => {
       console.log('Defered action invoked at finally section of MyAction! Outcome:', op.funcOutcome);
     });
 
 
-    const res = track.asScope({ name: 'Some running operation...' }, () => {
+    const res = track.scope({ name: 'Some running operation...' }, () => {
       return a + b;
     });
 

specs/hooks.decorator.spec.ts

@@ -1,8 +1,8 @@
-import { TryCatchFinallyHooksBuilder } from '@/TryCatchFinallyHooks';
+import { Hooks } from '@/Hooks';
 
 test("log try finally asMethodDecorator", () => {
   const log = jest.fn();
-  const track = new TryCatchFinallyHooksBuilder().add<{ args: { name: string; }; }>({
+  const track = new Hooks().add<{ args: { name: string; }; }>({
     onTry(ctx) {
       log("onTry", ctx.args.name);
       return {
@@ -14,14 +14,14 @@ test("log try finally asMethodDecorator", () => {
         }
       };
     },
-  }).createDecorator();
+  });
 
 
 
   const myFuncOrig = jest.fn((a, b) => a + b);
 
   class MyClass {
-    @track({ name: "MyAction" })
+    @track.decor({ name: "MyAction" })
     myFunc(a: number, b: number) {
       return myFuncOrig(a, b);
     }

specs/hooks.function.spec.ts

@@ -1,8 +1,8 @@
-import { TryCatchFinallyHooksBuilder } from '@/TryCatchFinallyHooks';
+import { Hooks } from '@/Hooks';
 
 test("log try finally asFunction", () => {
   const log = jest.fn();
-  const track = new TryCatchFinallyHooksBuilder().add<{ args: { name: string; }; }>({
+  const track = new Hooks().add<{ args: { name: string; }; }>({
     onTry(ctx) {
       log("onTry", ctx.args.name);
       return {
@@ -17,7 +17,7 @@ test("log try finally asFunction", () => {
   });
 
   const myFuncOrig = jest.fn((a, b) => a + b);
-  const myFunc = track.asFunctionWrapper({ name: "MyAction" })(myFuncOrig);
+  const myFunc = track.wrap({ name: "MyAction" }, myFuncOrig);
   const res = myFunc(11, 22);
 
   expect(res).toBe(11 + 22);

specs/hooks.scope.spec.ts

@@ -1,16 +1,16 @@
 import 'jest-extended'
-import { TryCatchFinallyHooksBuilder } from '@/TryCatchFinallyHooks'
+import { Hooks } from '@/Hooks'
 
 test("log onTry asScope", () => {
   const log = jest.fn();
-  const track = new TryCatchFinallyHooksBuilder().add<{ args: { name: string; }; }>({
+  const track = new Hooks().add<{ args: { name: string; }; }>({
     onTry(ctx) {
       log("onTry", ctx.args.name);
     },
   });
 
   const myFunc = jest.fn((a, b) => a + b);
-  const res = track.asScope({ name: "MyAction" }, () => {
+  const res = track.scope({ name: "MyAction" }, () => {
     return myFunc(11, 22);
   });
 
@@ -23,7 +23,7 @@ test("log onTry asScope", () => {
 
 test("log try finally asScope",()=>{
   const log = jest.fn()
-  const track = new TryCatchFinallyHooksBuilder().add<{args:{name: string}}>({
+  const track = new Hooks().add<{args:{name: string}}>({
     onTry(ctx) {
       log("onTry",ctx.args.name)
       return {
@@ -38,7 +38,7 @@ test("log try finally asScope",()=>{
   })
 
   const myFunc = jest.fn((a,b)=>a+b)
-  const res = track.asScope({name:"MyAction"},()=>{
+  const res = track.scope({name:"MyAction"},()=>{
     return myFunc(11,22)
   })
 
@@ -54,7 +54,7 @@ test("log try finally asScope",()=>{
 test("async log onTry asScope",async ()=>{
   const logTry = jest.fn()
   const logFinally = jest.fn()
-  const track = new TryCatchFinallyHooksBuilder().add<{args:{name: string}}>({
+  const track = new Hooks().add<{args:{name: string}}>({
     onTry(ctx) {
       logTry("onTry",ctx.args.name)
       return {
@@ -71,7 +71,7 @@ test("async log onTry asScope",async ()=>{
     await delay(500)
     return a+b
   })
-  const res = await track.asScope({name:"MyAction"},async ()=>{
+  const res = await track.scope({name:"MyAction"},async ()=>{
     return await myFunc(11,22)
   })
 

src/Hooks.ts

@@ -0,0 +1,131 @@
+import { ITryCatchFinallyHook, TryCatchFinallyHook, DecoratorArgsOf, ITryCatchFinallyHooksCollection, IHooksFunc } from "./TryCatchFinallyHook";
+import { FunctionContext, WrappableFunction, createTryCatchFinally } from "./tryCatchFinally";
+
+
+  /** @inheritDoc {@link ITryCatchFinallyHooksCollection} */
+export class Hooks<FullHookContext extends FunctionContext = FunctionContext> implements ITryCatchFinallyHooksCollection<FullHookContext>
+{
+  private hooks:ITryCatchFinallyHook<any, any>[] = []
+
+  add<TNewContext extends {}={}, TryReturnContext={}>(hook: TryCatchFinallyHook<FullHookContext & TNewContext, TryReturnContext>): Hooks<FullHookContext & TNewContext & TryReturnContext>
+  {
+    if(hook instanceof Function)
+      return this.add({onTry: hook} as any)
+
+    this.hooks.push(hook);
+    return this as any;
+  }
+  
+  wrap<TFunc extends WrappableFunction>(args: DecoratorArgsOf<FullHookContext>|undefined, func:TFunc): TFunc
+  wrap<TFunc extends WrappableFunction>(func:TFunc):TFunc
+  //wrap(args?: DecoratorArgsOf<FullHookContext>): <TFunc extends WrappableFunction>(func:TFunc)=>TFunc // conflicts with decor
+  wrap()
+  {
+    const _this = this
+    const beforeHooksTry = this.beforeHooksTry.bind(this)
+    const afterHooksTry = this.afterHooksTry?.bind(this)
+    const [args, func] = arguments.length >= 2
+      ? [arguments[0] as DecoratorArgsOf<FullHookContext>|undefined, arguments[1] as WrappableFunction]
+      : arguments[0] instanceof Function? [undefined, arguments[0] as WrappableFunction]
+      : [arguments[0] as DecoratorArgsOf<FullHookContext>|undefined, undefined]
+
+    if(!func)
+      return (func: WrappableFunction)=> this.wrap(args, func)
+    
+    return createTryCatchFinally<typeof func, {args?: DecoratorArgsOf<FullHookContext>}>(func, {
+      onTry(ctxTry) {
+        if(args) (ctxTry as any).args = args
+        const hooksSorted = _this.hooks
+        const bht = beforeHooksTry(ctxTry as any)
+        let onTryHooks = hooksSorted.map(hook=> hook.onTry(ctxTry)!).filter(h=>h)
+
+        onTryHooks = onTryHooks.reduce( 
+          ([first,last], h)=>('lastInQueue' in h && h.lastInQueue? last.push(h): first.push(h), [first, last]),
+          [[] as typeof onTryHooks,[] as typeof onTryHooks]
+        ).flat()
+    
+        return {
+          onFinally(ctxFinally) {
+            for (const hr of onTryHooks) {
+              hr.onFinally?.(ctxFinally)
+            }
+            bht.onFinally?.()
+          },
+          onCatch(ctxCatch) {
+            for (const hr of onTryHooks) {
+              hr.onCatch?.(ctxCatch)
+            }
+            bht.onCatch?.()
+          }
+        }
+      },
+    })
+  }
+
+  /**
+   * @param args 
+   * @returns 
+   */
+  decor(args?: DecoratorArgsOf<FullHookContext>): MethodDecorator & (<TFunc extends WrappableFunction>(func:TFunc)=>TFunc)
+  {
+    return ((_target:any, _propertyKey, descriptor) => {
+      if(arguments.length==1 && typeof _target === 'function')
+        return this.wrap(args, _target as any)
+      const originalMethod = descriptor.value as any;
+      descriptor.value = this.wrap(args, originalMethod)
+    }) as MethodDecorator as any
+  }
+
+  scope<TResult>(args: DecoratorArgsOf<FullHookContext>, scope:()=>TResult):TResult
+  {
+    return this.wrap(args, scope)()
+  }
+
+  protected beforeHooksTry(ctx: FullHookContext):{
+    onCatch?(): void
+    onFinally?(): void
+  }
+  {
+    const _this = this
+    const prevContext = _this._currentContext
+    this._currentContext = ctx as any
+
+    return {
+      onFinally() {
+        _this._currentContext = prevContext
+      },
+    }
+  }
+  protected afterHooksTry?(ctx: FullHookContext):{
+    onCatch?(): void
+    onFinally?(): void
+  }
+
+  private _currentContext:(FullHookContext & FunctionContext)|undefined = undefined
+
+
+  /**
+   * Only safe to use in sync functions or in async functions before any awaited code.
+   * Otherwise, the context may be changed by another async function - in that case use callStack hook instead
+   */
+  get context(){
+    return this._currentContext
+  }
+
+  create():IHooksFunc<this>
+  {
+    const hookFunc:IHooksFunc<Hooks<FullHookContext>> = function()
+    {
+      const hooks = hookFunc.hooks
+      
+      if(arguments[0] instanceof Function || arguments[1] instanceof Function)
+        return hooks.wrap.apply(hooks, arguments as any)
+      //decor or wrap
+      return hooks.decor.apply(hooks, arguments as any)
+    } as any
+    hookFunc.hooks = this
+    hookFunc.scope = this.scope.bind(this)
+    Object.defineProperty(hookFunc, 'context', {get: ()=>hookFunc.hooks.context})
+    return hookFunc as any //IHooksFunc<Hooks<FullHookContext>>
+  }
+}

src/TryCatchFinallyHook.ts

@@ -0,0 +1,82 @@
+import { FunctionContext, WrappableFunction } from "./tryCatchFinally";
+
+export interface TryCatchFinallyHookFunc<TParentContext = FunctionContext, TryReturnContext = {}> {
+  (ctx: TParentContext & FunctionContext): void | {
+    context?: TryReturnContext;
+    onCatch?(ctx: FunctionContext & TParentContext & TryReturnContext): void;
+    onFinally?(ctx: FunctionContext & TParentContext & TryReturnContext): void;
+    /**
+     * If true, the hook will be executed after all other hooks
+     */
+    lastInQueue?: boolean;
+  };
+}
+
+export interface ITryCatchFinallyHook<TParentContext = FunctionContext, TrtReturnContext = {}> {
+  onTry: TryCatchFinallyHookFunc<TParentContext, TrtReturnContext>;
+}
+
+export type TryCatchFinallyHook<TParentContext = FunctionContext, TryReturnContext = {}> = TryCatchFinallyHookFunc<TParentContext, TryReturnContext> | ITryCatchFinallyHook<TParentContext, TryReturnContext>;
+
+
+export type HookContextOf<THook> = THook extends ITryCatchFinallyHook<infer T1, infer T2> ? T1 & T2 : never;
+
+export type DecoratorArgsOf<THookContext> = THookContext extends { args?: infer TArgs extends {}; } ? TArgs : {};
+
+export interface ITryCatchFinallyHooksCollection<THookContext extends FunctionContext=FunctionContext>
+{
+  /**
+   * @example
+   * ```ts
+   * class MyClass{
+   *    @track.decor({name: 'myMethod'})
+   *    myMethod(p1,p2){
+   *      ...doSomething...
+   *    }
+   * }
+   * ```
+   */
+  decor(args?: DecoratorArgsOf<THookContext>): MethodDecorator & (<TFunc extends WrappableFunction>(func:TFunc)=>TFunc)
+
+  /**
+   * @example
+   * ```ts
+   * const myFunc = track.wrap({name: 'myFunc'},(p1,p2)=>{
+   *   ...doSomething...
+   * })
+   * ```
+   */
+  wrap<TFunc extends WrappableFunction>(args: DecoratorArgsOf<THookContext>, func:TFunc):TFunc
+  wrap<TFunc extends WrappableFunction>(func:TFunc):TFunc
+
+  /**
+   * @example 
+   * ```ts
+   * const result = track.scope({name: 'some long running code block'},()=>{
+   *  ...doSomething...
+   * })
+   * ```
+   */
+  scope<T>(args: DecoratorArgsOf<THookContext>, scopeFn:()=>T):T;
+
+  /**
+   * add a hook to the collection, return this collection with upgraded type
+   * @param hook 
+   */
+  add<TNewContext extends {}={}, TExtra={}>(hook: TryCatchFinallyHook<THookContext & TNewContext, TExtra>):ITryCatchFinallyHooksCollection<THookContext & TNewContext & TExtra>
+
+  readonly context: THookContext | undefined
+
+  //create(): IHooksFunc<ITryCatchFinallyHooksCollection<THookContext>>
+}
+
+export type ContextOfHooks<THooksCollection extends ITryCatchFinallyHooksCollection<any>> = THooksCollection extends ITryCatchFinallyHooksCollection<infer T> ? T : never;
+
+export type IHooksFunc<THooksCollection extends ITryCatchFinallyHooksCollection<any>> 
+= THooksCollection['wrap'] 
+& THooksCollection['decor']
+& {
+  scope: THooksCollection['scope']
+  hooks: THooksCollection
+  readonly context: ContextOfHooks<THooksCollection>
+}