@optimizely-opal/opal-tool-ocp-sdk 1.1.0-beta.1 → 1.1.0-beta.2

package/src/service/Service.ts

@@ -1,5 +1,5 @@
 /* eslint-disable max-classes-per-file */
-import { AuthRequirement, IslandResponse, Parameter } from '../types/Models';
+import { AuthRequirement, IslandResponse, OAuthAuthData, OptiIdAuthData, Parameter } from '../types/Models';
 import { ToolError } from '../types/ToolError';
 import * as App from '@zaiusinc/app-sdk';
 import { logger, getAppContext } from '@zaiusinc/app-sdk';
@@ -53,14 +53,14 @@ export class InteractionResult {
 /**
  * Interaction definition for an Opal interaction
  */
-export class Interaction<TAuthData> {
+export class Interaction {
   public constructor(
     public name: string,
     public endpoint: string,
     public handler: (
       functionContext: ToolFunction | GlobalToolFunction,
       data: unknown,
-      authData?: TAuthData
+      authData: OptiIdAuthData | OAuthAuthData
     ) => Promise<InteractionResult>
   ) {}
 }
@@ -68,7 +68,7 @@ export class Interaction<TAuthData> {
 /**
  * Tool definition for an Opal tool
  */
-export class Tool<TAuthData> {
+export class Tool {
   /**
    * HTTP method for the endpoint (default: POST)
    */
@@ -91,7 +91,7 @@ export class Tool<TAuthData> {
     public handler: (
       functionContext: ToolFunction | GlobalToolFunction,
       params: unknown,
-      authData?: TAuthData
+      authData: OptiIdAuthData | OAuthAuthData
     ) => Promise<unknown>,
     public authRequirements: AuthRequirement[] = [DEFAULT_OPTIID_AUTH]
   ) {}
@@ -114,8 +114,8 @@ export class Tool<TAuthData> {
 }
 
 export class ToolsService {
-  private functions: Map<string, Tool<any>> = new Map();
-  private interactions: Map<string, Interaction<any>> = new Map();
+  private functions: Map<string, Tool> = new Map();
+  private interactions: Map<string, Interaction> = new Map();
 
   /**
    * Generate KV store key for tool overrides
@@ -144,7 +144,7 @@ export class ToolsService {
    * @param overrides Override data
    * @returns Tools with overrides applied
    */
-  private applyOverrides(tools: Array<Tool<any>>, overrides: StoredOverrides): Array<Tool<any>> {
+  private applyOverrides(tools: Tool[], overrides: StoredOverrides): Tool[] {
     return tools.map((tool) => {
       const override = overrides[tool.name];
       if (!override) {
@@ -207,7 +207,7 @@ export class ToolsService {
    * @param functionName Function name
    * @returns Tool definitions with overrides applied
    */
-  public async getToolsWithOverrides(appVersionId: string, functionName: string): Promise<Array<Tool<any>>> {
+  public async getToolsWithOverrides(appVersionId: string, functionName: string): Promise<Tool[]> {
     const tools = Array.from(this.functions.values());
     const overrides = await this.getOverrides(appVersionId, functionName);
 
@@ -259,20 +259,20 @@ export class ToolsService {
    * @param endpoint API endpoint for the tool
    * @param authRequirements Authentication requirements (optional - defaults to OptiID if not specified)
    */
-  public registerTool<TAuthData>(
+  public registerTool(
     name: string,
     description: string,
     handler: (
       functionContext: ToolFunction | GlobalToolFunction,
       params: unknown,
-      authData?: TAuthData
+      authData: OptiIdAuthData | OAuthAuthData
     ) => Promise<unknown>,
     parameters: Parameter[],
     endpoint: string,
     authRequirements?: AuthRequirement[]
   ): void {
     const resolvedAuthRequirements = this.withDefaultAuthRequirements(authRequirements);
-    const func = new Tool<TAuthData>(
+    const func = new Tool(
       name,
       description,
       parameters,
@@ -289,16 +289,16 @@ export class ToolsService {
    * @param handler Function implementing the tool
    * @param endpoint API endpoint for the tool
    */
-  public registerInteraction<TAuthData>(
+  public registerInteraction(
     name: string,
     handler: (
       functionContext: ToolFunction | GlobalToolFunction,
       data: unknown,
-      authData?: TAuthData
+      authData: OptiIdAuthData | OAuthAuthData
     ) => Promise<InteractionResult>,
     endpoint: string
   ): void {
-    const func = new Interaction<TAuthData>(name, endpoint, handler);
+    const func = new Interaction(name, endpoint, handler);
     this.interactions.set(endpoint, func);
   }
 
@@ -330,12 +330,17 @@ export class ToolsService {
 
       // Extract auth data from body JSON
       const authData = req.bodyJSON?.auth;
+
+      // Validate auth data is present if tool has auth requirements
+      if (func.authRequirements.length > 0 && !authData) {
+        throw new ToolError('Authentication data is required', 403);
+      }
+
       const result = await func.handler(functionContext, params, authData);
       return new App.Response(200, result);
     }
 
     // Handle interactions
-    // Auth is already validated by the function layer
     const interaction = this.interactions.get(req.path);
     if (interaction) {
       const params = req.bodyJSON?.data ?? req.bodyJSON;
@@ -343,6 +348,11 @@ export class ToolsService {
       // Extract auth data from body JSON
       const authData = req.bodyJSON?.auth;
 
+      // Interactions always require auth
+      if (!authData) {
+        throw new ToolError('Authentication data is required', 403);
+      }
+
       const result = await interaction.handler(functionContext, params, authData);
       return new App.Response(200, result);
     }

package/src/types/Models.ts

@@ -43,29 +43,38 @@ export class Parameter {
 }
 
 /**
- * Credentials structure
+ * Credentials structure ofr OptiID provider
  */
-export class OptiIdAuthDataCredentials {
+export interface OptiIdAuthDataCredentials {
+  customer_id: string;
+  instance_id: string;
+  access_token: string;
+  product_sku: string;
+}
 
-  public constructor(
-    public customer_id: string,
-    public instance_id: string,
-    public access_token: string,
-    public product_sku: string
-  ) {}
+/**
+ * Credentials structure for OAuth providers
+ */
+export interface OAuthProviderAuthDataCredentials {
+  access_token: string;
+ token_type: string;
+ expires_at: string;
 }
 
+export interface OptiIdAuthData {
+  provider: 'OptiID';
+  credentials: OptiIdAuthDataCredentials;
+}
+
+export interface OAuthAuthData {
+  provider: string;
+  credentials: OAuthProviderAuthDataCredentials;
+}
 
 /**
  * Auth data structure
  */
-export class OptiIdAuthData {
-
-  public constructor(
-    public provider: string,
-    public credentials: OptiIdAuthDataCredentials
-  ) {}
-}
+export type AuthData = OptiIdAuthData | OAuthAuthData;
 
 /**
  * Authentication requirements for an Opal tool