Added wrapper for transversals caller to use outside of our assembler

Author: benoitlahoz

docs/assemblerjs/api/transversal-weaver.md

@@ -302,21 +302,36 @@ Information about the point of execution where an advice is applied.
 
 ```typescript
 interface JoinPoint {
-  target: any;           // The target instance
-  methodName: string;    // The name of the method being called
-  args: any[];          // The arguments passed to the method
-  result?: any;         // The result of the method (for after advice)
-  error?: any;          // The error thrown by the method (if any)
+  target: any;                      // The target instance
+  methodName: string;               // The name of the method being called
+  args: any[];                      // The arguments passed to the method
+  result?: any;                     // The result of the method (for after advice)
+  error?: any;                      // The error thrown by the method (if any)
+  caller?: string;                  // Class name of the caller (if tracked)
+  callerIdentifier?: string | symbol; // Optional unique identifier for the caller
 }
 ```
 
+**Caller Properties:**
+
+- `caller` - The name of the class or component that initiated the method call. Populated automatically for DI-managed calls, or set via `TransversalWeaver.withCaller()` for external callers.
+- `callerIdentifier` - Optional identifier (typically a Symbol or UUID) to uniquely identify the caller. Useful for request tracing and correlation IDs.
+
 **Usage:**
 
 ```typescript
 function logJoinPoint(joinPoint: JoinPoint) {
   console.log('Method:', joinPoint.methodName);
   console.log('Args:', joinPoint.args);
   console.log('Result:', joinPoint.result);
+  
+  // Caller tracking
+  if (joinPoint.caller) {
+    console.log('Called by:', joinPoint.caller);
+    if (joinPoint.callerIdentifier) {
+      console.log('Caller ID:', joinPoint.callerIdentifier);
+    }
+  }
 }
 ```
 
@@ -328,6 +343,8 @@ Extended join point with control flow for advices.
 interface AdviceContext extends JoinPoint {
   proceed?(): any | Promise<any>;  // Continue to next advice or original method
   config?: Record<string, any>;    // Optional config from @Affect decorator
+  caller?: string;                 // Class name of the caller (inherited from JoinPoint)
+  callerIdentifier?: string | symbol; // Caller ID (inherited from JoinPoint)
 }
 ```
 
@@ -339,13 +356,24 @@ class MyTransversal {
   @Around('execution(*.*)')
   async intercept(context: AdviceContext) {
     console.log('Before:', context.methodName);
+    if (context.caller) {
+      console.log('Caller:', context.caller);
+    }
 
     // Call next advice or original method
     const result = await context.proceed!();
 
     console.log('After:', result);
     return result;
   }
+  
+  @Before('execution(*.delete)')
+  checkAuthority(context: AdviceContext) {
+    // Use caller information for authorization
+    if (context.caller && !this.canDelete(context.caller)) {
+      throw new Error(`${context.caller} not authorized to delete`);
+    }
+  }
 }
 ```
 

docs/assemblerjs/api/types.md

@@ -376,6 +376,184 @@ class LifecycleTransversal implements AbstractTransversal {
 }
 ```
 
+## Caller Tracking
+
+Transversals support caller tracking, allowing you to identify which assemblage or external component initiated a method call. This is useful for audit logging, permission checking, and request tracing.
+
+### Using Caller Information in Advices
+
+The `AdviceContext` provides caller information:
+
+- `caller` - The class name of the caller
+- `callerIdentifier` - Optional unique identifier (string or symbol) for the caller
+
+```typescript
+@Transversal()
+class AuditTransversal implements AbstractTransversal {
+  @Before('execution(*.*)')
+  auditCall(context: AdviceContext) {
+    console.log(
+      `[AUDIT] ${context.caller || 'Unknown'} called ${context.target.constructor.name}.${context.methodName}`
+    );
+  }
+
+  @Before('execution(*.delete)')
+  checkDeletePermission(context: AdviceContext) {
+    // Only allow deletions from specific callers
+    if (context.caller !== 'AdminService') {
+      throw new Error(`Access denied: ${context.caller} cannot delete`);
+    }
+  }
+}
+```
+
+### Tracking External Callers
+
+For callers outside the DI container (e.g., Vue components, external scripts), use `TransversalWeaver.withCaller()` or `TransversalWeaver.wrapCaller()`:
+
+#### One-time execution with withCaller
+
+```typescript
+import { TransversalWeaver } from 'assemblerjs';
+
+// In a Vue component
+export default {
+  methods: {
+    async saveUser() {
+      await TransversalWeaver.withCaller('UserEditComponent', async () => {
+        await this.userService.save(userData);
+        // Advices will see caller = 'UserEditComponent'
+      });
+    }
+  }
+};
+```
+
+#### Reusable wrapped functions with wrapCaller
+
+For functions you'll call multiple times, use `wrapCaller` to create a wrapped function:
+
+```typescript
+import { TransversalWeaver } from 'assemblerjs';
+
+// In a Vue component
+export default {
+  setup() {
+    // Create wrapped function once
+    const mergeClasses = TransversalWeaver.wrapCaller(
+      'LeafletMap',
+      'LeafletMap.vue',
+      (...args) => tailwind.mergeClasses(...args)
+    );
+
+    return {
+      // Can be called multiple times, always maintains caller context
+      mergeClasses
+    };
+  }
+};
+```
+
+### Setting Caller with Identifier
+
+For more detailed tracking, provide an identifier alongside the caller:
+
+```typescript
+@Transversal()
+class RequestTracingTransversal implements AbstractTransversal {
+  @Before('execution(*.*)')
+  traceRequest(context: AdviceContext) {
+    const callerId = context.callerIdentifier 
+      ? ` (ID: ${String(context.callerIdentifier)})`
+      : '';
+    console.log(`Request from: ${context.caller}${callerId}`);
+  }
+}
+
+// Usage
+const requestId = Symbol('request-123');
+await TransversalWeaver.withCaller('APIController', requestId, async () => {
+  await service.processRequest();
+});
+```
+
+### Getting Current Caller Context
+
+Access the current caller outside of advices using `TransversalWeaver.getCurrentCaller()`:
+
+```typescript
+class ServiceA {
+  someMethod() {
+    const caller = TransversalWeaver.getCurrentCaller();
+    if (caller) {
+      console.log(`Called by: ${caller.className} (ID: ${caller.identifier})`);
+    }
+  }
+}
+```
+
+### Working Without Transversals
+
+Caller tracking works even when no transversals are engaged:
+
+```typescript
+// No transversals needed for caller context to work
+@Assemblage()
+class App {
+  constructor(private service: ServiceA) {}
+
+  async run() {
+    await TransversalWeaver.withCaller('App', async () => {
+      const result = await this.service.someMethod();
+      // Even without advices, getCurrentCaller() will return 'App'
+    });
+  }
+}
+```
+
+### Use Cases
+
+1. **Audit Logging** - Track who accessed sensitive data
+   ```typescript
+   @Before('execution(*.findSensitiveData)')
+   auditAccess(context: AdviceContext) {
+     this.logger.info(`${context.caller} accessed sensitive data`);
+   }
+   ```
+
+2. **Permission Checking** - Restrict operations by caller
+   ```typescript
+   @Before('execution(*.delete)', 100)
+   checkAuthorization(context: AdviceContext) {
+     if (!this.canDelete(context.caller)) {
+       throw new Error(`${context.caller} not authorized to delete`);
+     }
+   }
+   ```
+
+3. **Request Tracing** - Track request flow across services
+   ```typescript
+   @Before('execution(*.*)')
+   traceFlow(context: AdviceContext) {
+     if (context.callerIdentifier) {
+       console.log(`[Trace ${context.callerIdentifier}] ${context.caller} → ${context.methodName}`);
+     }
+   }
+   ```
+
+4. **Conditional Behavior** - Different behavior based on caller
+   ```typescript
+   @Around('execution(*.getData)')
+   async getData(context: AdviceContext) {
+     if (context.caller === 'AdminService') {
+       return await context.proceed!(); // Full data
+     } else {
+       const data = await context.proceed!();
+       return this.filterSensitiveFields(data); // Filtered data
+     }
+   }
+   ```
+
 ## Performance Considerations
 
 - Transversals add overhead to method calls

docs/assemblerjs/core-concepts/transversals-aop.md

@@ -113,6 +113,10 @@ methodName(context: AdviceContext): void | Promise<void>
 - `methodName` - Name of the intercepted method
 - `args` - Array of arguments passed to the method
 - `config` - Optional configuration from @Affect decorator
+- `caller` (optional) - Class name of the component that initiated the call
+- `callerIdentifier` (optional) - Unique identifier for the caller (useful for tracing)
+
+See [Caller Tracking](../core-concepts/transversals-aop.md#caller-tracking) for detailed information.
 
 ### Examples
 
@@ -128,15 +132,29 @@ class LoggingTransversal {
 }
 ```
 
+#### With Caller Tracking
+
+```typescript
+@Transversal()
+class AuditTransversal {
+  @Before('execution(*.*)')
+  auditCall(context: AdviceContext) {
+    const caller = context.caller || 'Unknown';
+    console.log(`[AUDIT] ${caller} called ${context.methodName}`);
+  }
+}
+```
+
 #### With Priority
 
 ```typescript
 @Transversal()
 class SecurityTransversal {
   @Before('execution(*.delete*)', 100)  // High priority
   checkPermission(context: AdviceContext) {
-    if (!this.hasPermission()) {
-      throw new Error('Access denied');
+    // Only AdminService can delete
+    if (context.caller !== 'AdminService') {
+      throw new Error(`Access denied: ${context.caller}`);
     }
   }
 }
@@ -204,6 +222,8 @@ methodName(context: AdviceContext): void | Promise<void>
 ### AdviceContext Properties (in addition to @Before)
 
 - `result` - The return value of the intercepted method
+- `caller` (optional) - Class name of the component that initiated the call
+- `callerIdentifier` (optional) - Unique identifier for the caller
 
 ### Examples
 
@@ -219,6 +239,19 @@ class LoggingTransversal {
 }
 ```
 
+#### With Caller Information
+
+```typescript
+@Transversal()
+class AuditTransversal {
+  @After('execution(*.delete)')
+  auditDeletion(context: AdviceContext) {
+    const caller = context.caller || 'Unknown';
+    console.log(`[AUDIT] ${caller} deleted ${context.target.constructor.name}`);
+  }
+}
+```
+
 #### Processing Results
 
 ```typescript
@@ -283,6 +316,8 @@ methodName(context: AdviceContext): any | Promise<any>
 ### AdviceContext Properties (in addition to @Before/@After)
 
 - `proceed()` - Function to invoke the next advice or original method
+- `caller` (optional) - Class name of the component that initiated the call
+- `callerIdentifier` (optional) - Unique identifier for the caller
 
 ### Important
 
@@ -309,6 +344,27 @@ class PerformanceTransversal {
 }
 ```
 
+#### With Caller Tracking
+
+```typescript
+@Transversal()
+class DataFilteringTransversal {
+  @Around('execution(*.getData)')
+  async filterByRole(context: AdviceContext) {
+    const data = await context.proceed!();
+    
+    // Different filtering based on caller
+    if (context.caller === 'AdminDashboard') {
+      return data; // No filtering
+    } else if (context.caller === 'PublicAPI') {
+      return this.filterPublic(data);
+    } else {
+      return [];
+    }
+  }
+}
+```
+
 #### Error Handling
 
 ```typescript