@optimizely-opal/opal-tool-ocp-sdk 0.0.0-dev.3 → 0.0.0-dev.5

package/src/service/Service.test.ts

@@ -1,12 +1,16 @@
 import { toolsService, Tool, Interaction } from './Service';
 import { Parameter, ParameterType, AuthRequirement, OptiIdAuthDataCredentials, OptiIdAuthData } from '../types/Models';
+import { ToolFunction } from '../function/ToolFunction';
 import { logger } from '@zaiusinc/app-sdk';
 
-// Mock the logger
+// Mock the logger and other app-sdk exports
 jest.mock('@zaiusinc/app-sdk', () => ({
   logger: {
     error: jest.fn()
   },
+  Function: class {
+    public constructor(public request: any) {}
+  },
   Response: jest.fn().mockImplementation((status, data) => ({
     status,
     data,
@@ -199,11 +203,93 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           undefined
         );
       });
 
+      it('should execute tool with existing ToolFunction instance context', async () => {
+        // Create a mock ToolFunction instance
+        const mockToolFunctionInstance = {
+          someProperty: 'test-value',
+          someMethod: jest.fn()
+        };
+
+        const mockRequest = createMockRequest();
+        const response = await toolsService.processRequest(mockRequest, mockToolFunctionInstance);
+
+        expect(response.status).toBe(200);
+        expect(mockTool.handler).toHaveBeenCalledWith(
+          mockToolFunctionInstance, // functionContext - existing instance
+          { param1: 'test-value' },
+          undefined
+        );
+      });
+
+      it('should allow handler in ToolFunction subclass to access request object', async () => {
+        // Create a mock class that extends ToolFunction
+        class MockToolFunction extends ToolFunction {
+          public testMethod() {
+            return `path: ${this.request.path}`;
+          }
+
+          public getRequestPath() {
+            return this.request.path;
+          }
+        }
+
+        // Create an instance with a mock request
+        const mockRequest = createMockRequest({ path: '/test-path' });
+        const mockToolFunctionInstance = new MockToolFunction(mockRequest);
+
+        // Create a handler that will use the ToolFunction instance's methods and properties
+        const handlerThatAccessesRequest = jest.fn().mockImplementation((
+          functionContext: any,
+          params: any,
+          _authData: any
+        ) => {
+          // This simulates what would happen in a decorated method of a ToolFunction subclass
+          if (functionContext && functionContext instanceof MockToolFunction) {
+            return Promise.resolve({
+              success: true,
+              requestPath: functionContext.getRequestPath(), // Use public method to access request
+              testMethodResult: functionContext.testMethod(),
+              receivedParams: params
+            });
+          }
+          return Promise.resolve({ success: false, error: 'No valid function context' });
+        });
+
+        // Register a tool with our custom handler
+        toolsService.registerTool(
+          'test-toolfunction-access',
+          'Test handler access to ToolFunction instance',
+          handlerThatAccessesRequest,
+          [],
+          '/test-toolfunction-access'
+        );
+
+        const testRequest = createMockRequest({
+          path: '/test-toolfunction-access',
+          bodyJSON: { action: 'test' }
+        });
+
+        const response = await toolsService.processRequest(testRequest, mockToolFunctionInstance);
+
+        expect(response.status).toBe(200);
+        expect((response as any).data).toBeDefined();
+        expect((response as any).data.success).toBe(true);
+        expect((response as any).data.requestPath).toBe('/test-path');
+        expect((response as any).data.testMethodResult).toBe('path: /test-path');
+        expect((response as any).data.receivedParams).toEqual({ action: 'test' });
+        expect(handlerThatAccessesRequest).toHaveBeenCalledWith(
+          mockToolFunctionInstance, // functionContext is the ToolFunction instance
+          { action: 'test' },
+          undefined
+        );
+      });
+
       it('should execute tool with OptiID auth data when provided', async () => {
         const authData = new OptiIdAuthData(
           'optiId',
@@ -225,6 +311,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -240,6 +327,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -288,7 +376,7 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(interactionRequest);
 
         expect(response.status).toBe(200);
-        expect(mockInteraction.handler).toHaveBeenCalledWith({ param1: 'test-value' }, undefined);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(undefined, { param1: 'test-value' }, undefined);
       });
 
       it('should handle interaction request body without data wrapper', async () => {
@@ -301,7 +389,7 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(interactionRequest);
 
         expect(response.status).toBe(200);
-        expect(mockInteraction.handler).toHaveBeenCalledWith({ param1: 'test-value' }, undefined);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(undefined, { param1: 'test-value' }, undefined);
       });
 
       it('should execute interaction with OptiID auth data when provided', async () => {
@@ -326,6 +414,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockInteraction.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -353,6 +442,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockInteraction.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           {
             param1: 'test-value',
             auth: authData
@@ -430,7 +520,7 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(requestWithNullBody);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(null, undefined);
+        expect(mockTool.handler).toHaveBeenCalledWith(undefined, null, undefined);
       });
 
       it('should handle request with undefined bodyJSON', async () => {
@@ -450,7 +540,7 @@ describe('ToolsService', () => {
         const response = await toolsService.processRequest(requestWithUndefinedBody);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(undefined, undefined);
+        expect(mockTool.handler).toHaveBeenCalledWith(undefined, undefined, undefined);
       });
 
       it('should extract auth data from bodyJSON when body exists', async () => {
@@ -482,6 +572,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -510,6 +601,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -541,6 +633,7 @@ describe('ToolsService', () => {
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
+          undefined, // functionContext
           { param1: 'test-value' },
           authData
         );

package/src/service/Service.ts

@@ -22,7 +22,7 @@ export class Interaction<TAuthData> {
   public constructor(
     public name: string,
     public endpoint: string,
-    public handler: (data: unknown, authData?: TAuthData) => Promise<InteractionResult>
+    public handler: (functionContext: any, data: unknown, authData?: TAuthData) => Promise<InteractionResult>
   ) {}
 }
 
@@ -49,7 +49,7 @@ export class Tool<TAuthData> {
     public description: string,
     public parameters: Parameter[],
     public endpoint: string,
-    public handler: (params: unknown, authData?: TAuthData) => Promise<unknown>,
+    public handler: (functionContext: any, params: unknown, authData?: TAuthData) => Promise<unknown>,
     public authRequirements?: AuthRequirement[]
   ) {}
 
@@ -104,7 +104,7 @@ export class ToolsService {
   public registerTool<TAuthData>(
     name: string,
     description: string,
-    handler: (params: unknown, authData?: TAuthData) => Promise<unknown>,
+    handler: (functionContext: any, params: unknown, authData?: TAuthData) => Promise<unknown>,
     parameters: Parameter[],
     endpoint: string,
     authRequirements?: AuthRequirement[]
@@ -121,14 +121,14 @@ export class ToolsService {
    */
   public registerInteraction<TAuthData>(
     name: string,
-    handler: (data: unknown, authData?: TAuthData) => Promise<InteractionResult>,
+    handler: (functionContext: any, data: unknown, authData?: TAuthData) => Promise<InteractionResult>,
     endpoint: string
   ): void {
     const func = new Interaction<TAuthData>(name, endpoint, handler);
     this.interactions.set(endpoint, func);
   }
 
-  public async processRequest(req: App.Request): Promise<App.Response> {
+  public async processRequest(req: App.Request, functionContext?: any): Promise<App.Response> {
     if (req.path === '/discovery') {
       return new App.Response(200, { functions: Array.from(this.functions.values()).map((f) => f.toJSON()) });
     } else {
@@ -145,7 +145,7 @@ export class ToolsService {
           // Extract auth data from body JSON
           const authData = req.bodyJSON ? req.bodyJSON.auth : undefined;
 
-          const result = await func.handler(params, authData);
+          const result = await func.handler(functionContext, params, authData);
           return new App.Response(200, result);
         } catch (error: any) {
           logger.error(`Error in function ${func.name}:`, error);
@@ -166,7 +166,7 @@ export class ToolsService {
           // Extract auth data from body JSON
           const authData = req.bodyJSON ? req.bodyJSON.auth : undefined;
 
-          const result = await interaction.handler(params, authData);
+          const result = await interaction.handler(functionContext, params, authData);
           return new App.Response(200, result);
         } catch (error: any) {
           logger.error(`Error in function ${interaction.name}:`, error);