Add API aspects - WIP

src/API.ts

@@ -290,10 +290,23 @@ export interface APILayer {
     name: string
 }
 
+export type FunctionInterceptor = (name: string, original: Function) => Function
+export type PropertyInterceptor = (name: string, original: any) => any
+
+export interface APIAspect {
+    readonly name: string
+    readonly interceptFunction?: FunctionInterceptor
+    readonly interceptProperty?: PropertyInterceptor
+    readonly descendNestedLevel?: number
+}
+
+export type APIAspectFactory = (apiKey: AnySlotKey, normalizedName: string) => APIAspect
+
 export interface AppHostOptions {
     readonly logger?: HostLogger
     readonly monitoring: MonitoringOptions
     readonly layers?: APILayer[] | APILayer[][]
+    readonly apiAspects?: APIAspectFactory[]
     readonly disableLayersValidation?: boolean
     readonly disableCheckCircularDependencies?: boolean
     readonly enableStickyErrorBoundaries?: boolean

src/appHost.ts

@@ -47,6 +47,7 @@ import { ConsoleHostLogger, createShellLogger } from './loggers'
 import { monitorAPI } from './monitorAPI'
 import { Graph, Tarjan } from './tarjanGraph'
 import { setupDebugInfo } from './repluggableAppDebug'
+import { interceptAnyObject } from './interceptAnyObject'
 
 const isMultiArray = <T>(v: T[] | T[][]): v is T[][] => _.every(v, _.isArray)
 const castMultiArray = <T>(v: T[] | T[][]): T[][] => {
@@ -881,14 +882,30 @@ miss: ${memoizedWithMissHit.miss}
                     )
                 }
 
+                const applyAPIAspects = (inner: TAPI): TAPI => {
+                    const normalizedName = normalizeApiName(slotKeyToName(key))
+
+                    let result = monitorAPI(shell, options, normalizedName, api /*, trace, memoizedArr*/, apiOptions)
+
+                    const aspectFactories = options.apiAspects
+
+                    if (aspectFactories) {
+                        for (const aspectFactory of aspectFactories) {
+                            const aspect = aspectFactory(key, normalizedName)
+                            result = interceptAnyObject(
+                                result,
+                                aspect.interceptFunction,
+                                aspect.interceptProperty,
+                                aspect.descendNestedLevel
+                            )
+                        }
+                    }
+
+                    return result
+                }
+
                 const api = factory()
-                const monitoredAPI = monitorAPI(
-                    shell,
-                    options,
-                    normalizeApiName(slotKeyToName(key)),
-                    api /*, trace, memoizedArr*/,
-                    apiOptions
-                )
+                const apiWithAspects = applyAPIAspects(api)
                 const apiSlot = declareSlot<TAPI>(key)
 
                 APILayers.set(
@@ -900,7 +917,7 @@ miss: ${memoizedWithMissHit.miss}
                               .value()
                         : undefined
                 )
-                apiSlot.contribute(shell, monitoredAPI)
+                apiSlot.contribute(shell, apiWithAspects)
 
                 readyAPIs.add(key)
 
@@ -910,7 +927,7 @@ miss: ${memoizedWithMissHit.miss}
                     setInstalledShellNames(_.difference(shellNames, _.map(unReadyEntryPointsStore.get(), 'name')))
                 }
 
-                return monitoredAPI
+                return apiWithAspects
             },
 
             contributeState<TState, TAction extends AnyAction = AnyAction>(

src/interceptAnyObject.ts

@@ -1,10 +1,9 @@
 import _ from 'lodash'
+import { FunctionInterceptor, PropertyInterceptor } from './API'
 
 export interface AnyObject {
     [key: string]: any
 }
-export type FunctionInterceptor = (name: string, original: Function) => Function
-export type PropertyInterceptor = (name: string, original: any) => any
 
 export function interceptAnyObject<T extends AnyObject>(
     inner: T,

test/interceptAnyObject.spec.ts

@@ -1,5 +1,6 @@
 import _ from 'lodash'
-import { interceptAnyObject, FunctionInterceptor, PropertyInterceptor } from '../src/interceptAnyObject'
+import { FunctionInterceptor, PropertyInterceptor } from '../src/API'
+import { interceptAnyObject } from '../src/interceptAnyObject'
 
 type LogSpy = jest.Mock<void, string[]>