@optimizely-opal/opal-tool-ocp-sdk 0.0.0-beta.4 → 0.0.0-beta.6

package/src/service/Service.test.ts

@@ -22,6 +22,7 @@ jest.mock('@zaiusinc/app-sdk', () => ({
 describe('ToolsService', () => {
   let mockTool: Tool<unknown>;
   let mockInteraction: Interaction<unknown>;
+  let mockToolFunction: ToolFunction;
 
   beforeEach(() => {
     // Clear registered functions and interactions before each test
@@ -31,6 +32,14 @@ describe('ToolsService', () => {
     // Reset all mocks
     jest.clearAllMocks();
 
+    // Create mock ToolFunction
+    mockToolFunction = {
+      ready: jest.fn().mockResolvedValue(true),
+      perform: jest.fn(),
+      validateBearerToken: jest.fn().mockReturnValue(true),
+      request: {} as any
+    } as any;
+
     // Create mock tool handler
     const mockToolHandler = jest.fn().mockResolvedValue({ result: 'success' });
 
@@ -94,7 +103,7 @@ describe('ToolsService', () => {
         );
 
         const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest);
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(response).toHaveProperty('bodyJSON');
@@ -119,7 +128,7 @@ describe('ToolsService', () => {
 
       it('should return empty functions array when no tools are registered', async () => {
         const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest);
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(response.bodyAsU8Array).toBeDefined();
@@ -153,7 +162,7 @@ describe('ToolsService', () => {
         );
 
         const discoveryRequest = createMockRequest({ path: '/discovery' });
-        const response = await toolsService.processRequest(discoveryRequest);
+        const response = await toolsService.processRequest(discoveryRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
 
@@ -199,11 +208,11 @@ describe('ToolsService', () => {
 
       it('should execute tool successfully with parameters', async () => {
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -213,8 +222,12 @@ describe('ToolsService', () => {
         // Create a mock ToolFunction instance
         const mockToolFunctionInstance = {
           someProperty: 'test-value',
-          someMethod: jest.fn()
-        };
+          someMethod: jest.fn(),
+          ready: jest.fn().mockResolvedValue(true),
+          perform: jest.fn(),
+          validateBearerToken: jest.fn().mockReturnValue(true),
+          request: {} as any
+        } as any;
 
         const mockRequest = createMockRequest();
         const response = await toolsService.processRequest(mockRequest, mockToolFunctionInstance);
@@ -307,11 +320,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithAuth);
+        const response = await toolsService.processRequest(requestWithAuth, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -323,11 +336,11 @@ describe('ToolsService', () => {
           body: JSON.stringify({ param1: 'test-value' })
         });
 
-        const response = await toolsService.processRequest(requestWithoutWrapper);
+        const response = await toolsService.processRequest(requestWithoutWrapper, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -338,7 +351,7 @@ describe('ToolsService', () => {
         jest.mocked(mockTool.handler).mockRejectedValueOnce(new Error(errorMessage));
 
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
         expect(logger.error).toHaveBeenCalledWith(
@@ -351,7 +364,7 @@ describe('ToolsService', () => {
         jest.mocked(mockTool.handler).mockRejectedValueOnce({});
 
         const mockRequest = createMockRequest();
-        const response = await toolsService.processRequest(mockRequest);
+        const response = await toolsService.processRequest(mockRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
       });
@@ -373,10 +386,10 @@ describe('ToolsService', () => {
           body: JSON.stringify({ data: { param1: 'test-value' } })
         });
 
-        const response = await toolsService.processRequest(interactionRequest);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockInteraction.handler).toHaveBeenCalledWith(undefined, { param1: 'test-value' }, undefined);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, undefined);
       });
 
       it('should handle interaction request body without data wrapper', async () => {
@@ -386,10 +399,10 @@ describe('ToolsService', () => {
           body: JSON.stringify({ param1: 'test-value' })
         });
 
-        const response = await toolsService.processRequest(interactionRequest);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockInteraction.handler).toHaveBeenCalledWith(undefined, { param1: 'test-value' }, undefined);
+        expect(mockInteraction.handler).toHaveBeenCalledWith(mockToolFunction, { param1: 'test-value' }, undefined);
       });
 
       it('should execute interaction with OptiID auth data when provided', async () => {
@@ -410,11 +423,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(interactionRequest);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockInteraction.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -438,11 +451,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(interactionRequest);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockInteraction.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           {
             param1: 'test-value',
             auth: authData
@@ -460,7 +473,7 @@ describe('ToolsService', () => {
           bodyJSON: { data: { param1: 'test-value' } }
         });
 
-        const response = await toolsService.processRequest(interactionRequest);
+        const response = await toolsService.processRequest(interactionRequest, mockToolFunction);
 
         expect(response.status).toBe(500);
         expect(logger.error).toHaveBeenCalledWith(
@@ -473,7 +486,7 @@ describe('ToolsService', () => {
     describe('error cases', () => {
       it('should return 404 when no matching tool or interaction is found', async () => {
         const unknownRequest = createMockRequest({ path: '/unknown-endpoint' });
-        const response = await toolsService.processRequest(unknownRequest);
+        const response = await toolsService.processRequest(unknownRequest, mockToolFunction);
 
         expect(response.status).toBe(404);
       });
@@ -496,7 +509,7 @@ describe('ToolsService', () => {
           path: '/optid-auth-tool'
         });
 
-        const response = await toolsService.processRequest(authRequest);
+        const response = await toolsService.processRequest(authRequest, mockToolFunction);
 
         expect(response.status).toBe(200);
       });
@@ -517,10 +530,10 @@ describe('ToolsService', () => {
           body: null
         });
 
-        const response = await toolsService.processRequest(requestWithNullBody);
+        const response = await toolsService.processRequest(requestWithNullBody, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(undefined, null, undefined);
+        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, null, undefined);
       });
 
       it('should handle request with undefined bodyJSON', async () => {
@@ -537,10 +550,10 @@ describe('ToolsService', () => {
           body: undefined
         });
 
-        const response = await toolsService.processRequest(requestWithUndefinedBody);
+        const response = await toolsService.processRequest(requestWithUndefinedBody, mockToolFunction);
 
         expect(response.status).toBe(200);
-        expect(mockTool.handler).toHaveBeenCalledWith(undefined, undefined, undefined);
+        expect(mockTool.handler).toHaveBeenCalledWith(mockToolFunction, undefined, undefined);
       });
 
       it('should extract auth data from bodyJSON when body exists', async () => {
@@ -568,11 +581,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithAuth);
+        const response = await toolsService.processRequest(requestWithAuth, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );
@@ -597,11 +610,11 @@ describe('ToolsService', () => {
           })
         });
 
-        const response = await toolsService.processRequest(requestWithoutAuth);
+        const response = await toolsService.processRequest(requestWithoutAuth, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           undefined
         );
@@ -629,11 +642,11 @@ describe('ToolsService', () => {
           body: ''
         });
 
-        const response = await toolsService.processRequest(requestWithAuthButNoBody);
+        const response = await toolsService.processRequest(requestWithAuthButNoBody, mockToolFunction);
 
         expect(response.status).toBe(200);
         expect(mockTool.handler).toHaveBeenCalledWith(
-          undefined, // functionContext
+          mockToolFunction, // functionContext
           { param1: 'test-value' },
           authData
         );

package/src/service/Service.ts

@@ -2,6 +2,7 @@
 import { AuthRequirement, Parameter } from '../types/Models';
 import * as App from '@zaiusinc/app-sdk';
 import { logger } from '@zaiusinc/app-sdk';
+import { ToolFunction } from '../function/ToolFunction';
 
 
 
@@ -22,7 +23,7 @@ export class Interaction<TAuthData> {
   public constructor(
     public name: string,
     public endpoint: string,
-    public handler: (functionContext: any, data: unknown, authData?: TAuthData) => Promise<InteractionResult>
+    public handler: (functionContext: ToolFunction, data: unknown, authData?: TAuthData) => Promise<InteractionResult>
   ) {}
 }
 
@@ -49,7 +50,7 @@ export class Tool<TAuthData> {
     public description: string,
     public parameters: Parameter[],
     public endpoint: string,
-    public handler: (functionContext: any, params: unknown, authData?: TAuthData) => Promise<unknown>,
+    public handler: (functionContext: ToolFunction, params: unknown, authData?: TAuthData) => Promise<unknown>,
     public authRequirements?: AuthRequirement[]
   ) {}
 
@@ -104,7 +105,7 @@ export class ToolsService {
   public registerTool<TAuthData>(
     name: string,
     description: string,
-    handler: (functionContext: any, params: unknown, authData?: TAuthData) => Promise<unknown>,
+    handler: (functionContext: ToolFunction, params: unknown, authData?: TAuthData) => Promise<unknown>,
     parameters: Parameter[],
     endpoint: string,
     authRequirements?: AuthRequirement[]
@@ -121,14 +122,15 @@ export class ToolsService {
    */
   public registerInteraction<TAuthData>(
     name: string,
-    handler: (functionContext: any, data: unknown, authData?: TAuthData) => Promise<InteractionResult>,
+    handler: (functionContext: ToolFunction, 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, functionContext?: any): Promise<App.Response> {
+  public async processRequest(req: App.Request,
+                              functionContext: ToolFunction): Promise<App.Response> {
     if (req.path === '/discovery') {
       return new App.Response(200, { functions: Array.from(this.functions.values()).map((f) => f.toJSON()) });
     } else {