refactor: assign names to wrapping methods created to invoke modules

src/module_caller.ts

@@ -13,7 +13,7 @@ import type { ModuleHandler, ModuleCallable, Constructor } from './types.js'
 
 /**
  * The moduleCaller works around a very specific pattern we use with
- * AdonisJS, ie to constructor classes and call methods using the
+ * AdonisJS, ie to construct classes and call methods using the
  * container.
  *
  * For example: Controllers of AdonisJS allows defining a controller
@@ -116,13 +116,15 @@ export function moduleCaller(target: Constructor<any>, method: string) {
     >(container?: T): ModuleHandler<T, Args> {
       if (container) {
         return {
+          name: `${target.name}.${method}`,
           async handle(...args: Args) {
             return container.call(await container.make(target), method, args)
           },
         } as ModuleHandler<T, Args>
       }
 
       return {
+        name: `${target.name}.${method}`,
         async handle(resolver: ContainerResolver<any> | Container<any>, ...args: Args) {
           return resolver.call(await resolver.make(target), method, args)
         },

src/module_importer.ts

@@ -136,6 +136,7 @@ export function moduleImporter(
 
       if (container) {
         return {
+          name: importFn.name,
           async handle(...args: Args) {
             defaultExport = defaultExport || (await importDefault(importFn))
             return container.call(await container.make(defaultExport), method, args)
@@ -144,6 +145,7 @@ export function moduleImporter(
       }
 
       return {
+        name: importFn.name,
         async handle(resolver: ContainerResolver<any> | Container<any>, ...args: Args) {
           defaultExport = defaultExport || (await importDefault(importFn))
           return resolver.call(await resolver.make(defaultExport), method, args)

src/types.ts

@@ -176,8 +176,10 @@ export type ModuleCallable<T, Args extends any[]> = T extends undefined
  */
 export type ModuleHandler<T, Args extends any[]> = T extends undefined
   ? {
+      name?: string
       handle(resolver: ContainerResolver<any> | Container<any>, ...args: Args): Promise<any>
     }
   : {
+      name?: string
       handle(...args: Args): Promise<any>
     }