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

package/src/validation/ParameterValidator.test.ts

@@ -0,0 +1,341 @@
+import { ParameterValidator } from './ParameterValidator';
+import { Parameter, ParameterType } from '../types/Models';
+
+describe('ParameterValidator', () => {
+  describe('validate', () => {
+    it('should pass validation for valid parameters', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true),
+        new Parameter('age', ParameterType.Integer, 'User age', false),
+        new Parameter('score', ParameterType.Number, 'User score', false),
+        new Parameter('active', ParameterType.Boolean, 'Is active', false),
+        new Parameter('tags', ParameterType.List, 'User tags', false),
+        new Parameter('config', ParameterType.Dictionary, 'User config', false)
+      ];
+
+      const validParams = {
+        name: 'John Doe',
+        age: 25,
+        score: 85.5,
+        active: true,
+        tags: ['admin', 'user'],
+        config: { theme: 'dark', language: 'en' }
+      };
+
+      const result = ParameterValidator.validate(validParams, paramDefs);
+
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should fail validation for missing required parameters', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true),
+        new Parameter('email', ParameterType.String, 'User email', true)
+      ];
+
+      const params = {
+        name: 'John Doe'
+        // email is missing
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toEqual({
+        field: 'email',
+        message: "Required parameter 'email' is missing"
+      });
+    });
+
+    it('should fail validation for wrong parameter types', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true),
+        new Parameter('age', ParameterType.Integer, 'User age', true),
+        new Parameter('active', ParameterType.Boolean, 'Is active', true),
+        new Parameter('tags', ParameterType.List, 'User tags', true),
+        new Parameter('config', ParameterType.Dictionary, 'User config', true)
+      ];
+
+      const invalidParams = {
+        name: 123, // should be string
+        age: '25', // should be integer
+        active: 'true', // should be boolean
+        tags: 'tag1,tag2', // should be array
+        config: 'invalid' // should be object
+      };
+
+      const result = ParameterValidator.validate(invalidParams, paramDefs);
+
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(5);
+
+      expect(result.errors[0].field).toBe('name');
+      expect(result.errors[0].message).toContain('must be a string');
+
+      expect(result.errors[1].field).toBe('age');
+      expect(result.errors[1].message).toContain('must be an integer');
+
+      expect(result.errors[2].field).toBe('active');
+      expect(result.errors[2].message).toContain('must be a boolean');
+
+      expect(result.errors[3].field).toBe('tags');
+      expect(result.errors[3].message).toContain('must be an array');
+
+      expect(result.errors[4].field).toBe('config');
+      expect(result.errors[4].message).toContain('must be an object');
+    });
+
+    it('should handle null/undefined parameters correctly', () => {
+      const paramDefs = [
+        new Parameter('required', ParameterType.String, 'Required param', true),
+        new Parameter('optional', ParameterType.String, 'Optional param', false)
+      ];
+
+      const result1 = ParameterValidator.validate(null, paramDefs);
+      expect(result1.isValid).toBe(false);
+      expect(result1.errors).toHaveLength(1);
+      expect(result1.errors[0].field).toBe('required');
+
+      const result2 = ParameterValidator.validate(undefined, paramDefs);
+      expect(result2.isValid).toBe(false);
+      expect(result2.errors).toHaveLength(1);
+      expect(result2.errors[0].field).toBe('required');
+    });
+
+    it('should allow optional parameters to be missing', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true),
+        new Parameter('age', ParameterType.Integer, 'User age', false)
+      ];
+
+      const params = {
+        name: 'John Doe'
+        // age is optional and missing
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should distinguish between integer and number types', () => {
+      const paramDefs = [
+        new Parameter('count', ParameterType.Integer, 'Item count', true),
+        new Parameter('score', ParameterType.Number, 'Score value', true)
+      ];
+
+      const params1 = {
+        count: 25.5, // should be integer, not float
+        score: 85.5  // number is fine
+      };
+
+      const result1 = ParameterValidator.validate(params1, paramDefs);
+      expect(result1.isValid).toBe(false);
+      expect(result1.errors).toHaveLength(1);
+      expect(result1.errors[0].field).toBe('count');
+      expect(result1.errors[0].message).toContain('must be an integer');
+
+      const params2 = {
+        count: 25,   // integer is fine
+        score: 85.5  // number is fine
+      };
+
+      const result2 = ParameterValidator.validate(params2, paramDefs);
+      expect(result2.isValid).toBe(true);
+      expect(result2.errors).toHaveLength(0);
+    });
+
+    it('should handle array vs object distinction', () => {
+      const paramDefs = [
+        new Parameter('tags', ParameterType.List, 'Tag list', true),
+        new Parameter('config', ParameterType.Dictionary, 'Config object', true)
+      ];
+
+      const params = {
+        tags: { 0: 'tag1', 1: 'tag2' }, // object that looks like array
+        config: ['key1', 'key2'] // array instead of object
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(2);
+
+      expect(result.errors[0].field).toBe('tags');
+      expect(result.errors[0].message).toContain('must be an array');
+
+      expect(result.errors[1].field).toBe('config');
+      expect(result.errors[1].message).toContain('must be an object');
+    });
+
+    it('should handle null values for optional parameters', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true),
+        new Parameter('age', ParameterType.Integer, 'User age', false)
+      ];
+
+      const params = {
+        name: 'John Doe',
+        age: null // null for optional parameter should be allowed
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should handle edge cases for number validation', () => {
+      const paramDefs = [
+        new Parameter('score', ParameterType.Number, 'Score value', true)
+      ];
+
+      // Test NaN
+      const params1 = { score: NaN };
+      const result1 = ParameterValidator.validate(params1, paramDefs);
+      expect(result1.isValid).toBe(false);
+      expect(result1.errors[0].message).toContain('must be a number');
+
+      // Test Infinity
+      const params2 = { score: Infinity };
+      const result2 = ParameterValidator.validate(params2, paramDefs);
+      expect(result2.isValid).toBe(true);
+      expect(result2.errors).toHaveLength(0);
+
+      // Test negative numbers
+      const params3 = { score: -42.5 };
+      const result3 = ParameterValidator.validate(params3, paramDefs);
+      expect(result3.isValid).toBe(true);
+      expect(result3.errors).toHaveLength(0);
+    });
+
+    it('should handle edge cases for integer validation', () => {
+      const paramDefs = [
+        new Parameter('count', ParameterType.Integer, 'Item count', true)
+      ];
+
+      // Test negative integers
+      const params1 = { count: -5 };
+      const result1 = ParameterValidator.validate(params1, paramDefs);
+      expect(result1.isValid).toBe(true);
+      expect(result1.errors).toHaveLength(0);
+
+      // Test zero
+      const params2 = { count: 0 };
+      const result2 = ParameterValidator.validate(params2, paramDefs);
+      expect(result2.isValid).toBe(true);
+      expect(result2.errors).toHaveLength(0);
+
+      // Test very large integers
+      const params3 = { count: Number.MAX_SAFE_INTEGER };
+      const result3 = ParameterValidator.validate(params3, paramDefs);
+      expect(result3.isValid).toBe(true);
+      expect(result3.errors).toHaveLength(0);
+    });
+
+    it('should handle empty arrays and objects', () => {
+      const paramDefs = [
+        new Parameter('tags', ParameterType.List, 'Tag list', true),
+        new Parameter('config', ParameterType.Dictionary, 'Config object', true)
+      ];
+
+      const params = {
+        tags: [], // empty array should be valid
+        config: {} // empty object should be valid
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should handle special string values', () => {
+      const paramDefs = [
+        new Parameter('text', ParameterType.String, 'Text value', true)
+      ];
+
+      // Test empty string
+      const params1 = { text: '' };
+      const result1 = ParameterValidator.validate(params1, paramDefs);
+      expect(result1.isValid).toBe(true);
+      expect(result1.errors).toHaveLength(0);
+
+      // Test string with special characters
+      const params2 = { text: 'Hello\nWorld\t!' };
+      const result2 = ParameterValidator.validate(params2, paramDefs);
+      expect(result2.isValid).toBe(true);
+      expect(result2.errors).toHaveLength(0);
+    });
+
+    it('should handle multiple validation errors', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true),
+        new Parameter('age', ParameterType.Integer, 'User age', true),
+        new Parameter('email', ParameterType.String, 'User email', true)
+      ];
+
+      const params = {
+        name: 123, // wrong type
+        age: '25' // wrong type
+        // email is missing
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toHaveLength(3);
+
+      expect(result.errors.some((e) => e.field === 'name')).toBe(true);
+      expect(result.errors.some((e) => e.field === 'age')).toBe(true);
+      expect(result.errors.some((e) => e.field === 'email')).toBe(true);
+    });
+
+    it('should handle tools with no parameter definitions', () => {
+      const result = ParameterValidator.validate({ someParam: 'value' }, []);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should handle extra parameters not in definition', () => {
+      const paramDefs = [
+        new Parameter('name', ParameterType.String, 'User name', true)
+      ];
+
+      const params = {
+        name: 'John Doe',
+        extraParam: 'should be ignored'
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should handle nested objects and arrays', () => {
+      const paramDefs = [
+        new Parameter('config', ParameterType.Dictionary, 'Config object', true),
+        new Parameter('matrix', ParameterType.List, 'Matrix data', true)
+      ];
+
+      const params = {
+        config: {
+          nested: {
+            deep: {
+              value: 'test'
+            }
+          },
+          array: [1, 2, 3]
+        },
+        matrix: [
+          [1, 2, 3],
+          [4, 5, 6],
+          { nested: 'object in array' }
+        ]
+      };
+
+      const result = ParameterValidator.validate(params, paramDefs);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+});

package/src/validation/ParameterValidator.ts

@@ -0,0 +1,153 @@
+import { Parameter, ParameterType } from '../types/Models';
+
+/**
+ * Validation error details
+ */
+export interface ValidationError {
+  field: string;
+  message: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+  isValid: boolean;
+  errors: ValidationError[];
+}
+
+/**
+ * Parameter validator for tool inputs
+ */
+export class ParameterValidator {
+  /**
+   * Validate parameters against their definitions
+   * @param params The actual parameters received
+   * @param parameterDefinitions The expected parameter definitions
+   * @returns Validation result with any errors found
+   */
+  public static validate(
+    params: any,
+    parameterDefinitions: Parameter[]
+  ): ValidationResult {
+    const errors: ValidationError[] = [];
+
+    // Validate each defined parameter
+    for (const paramDef of parameterDefinitions) {
+      const value = params ? params[paramDef.name] : undefined;
+
+      // Check if required parameter is missing
+      if (paramDef.required && (value === undefined || value === null)) {
+        errors.push({
+          field: paramDef.name,
+          message: `Required parameter '${paramDef.name}' is missing`
+        });
+        continue;
+      }
+
+      // Skip validation if parameter is optional and not provided
+      if (!paramDef.required && (value === undefined || value === null)) {
+        continue;
+      }
+
+      // Validate parameter type
+      const typeError = this.validateParameterType(paramDef.name, value, paramDef.type);
+      if (typeError) {
+        errors.push(typeError);
+      }
+    }
+
+    return { isValid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validate a single parameter's type
+   * @param paramName Parameter name
+   * @param value Parameter value
+   * @param expectedType Expected parameter type
+   * @returns Validation error if invalid, null if valid
+   */
+  private static validateParameterType(
+    paramName: string,
+    value: any,
+    expectedType: ParameterType
+  ): ValidationError | null {
+    const actualType = this.getActualType(value);
+
+    switch (expectedType) {
+    case ParameterType.String:
+      if (typeof value !== 'string') {
+        return {
+          field: paramName,
+          message: `Parameter '${paramName}' must be a string, but received ${actualType}`
+        };
+      }
+      break;
+
+    case ParameterType.Integer:
+      if (!Number.isInteger(value)) {
+        return {
+          field: paramName,
+          message: `Parameter '${paramName}' must be an integer, but received ${actualType}`
+        };
+      }
+      break;
+
+    case ParameterType.Number:
+      if (typeof value !== 'number' || isNaN(value)) {
+        return {
+          field: paramName,
+          message: `Parameter '${paramName}' must be a number, but received ${actualType}`
+        };
+      }
+      break;
+
+    case ParameterType.Boolean:
+      if (typeof value !== 'boolean') {
+        return {
+          field: paramName,
+          message: `Parameter '${paramName}' must be a boolean, but received ${actualType}`
+        };
+      }
+      break;
+
+    case ParameterType.List:
+      if (!Array.isArray(value)) {
+        return {
+          field: paramName,
+          message: `Parameter '${paramName}' must be an array, but received ${actualType}`
+        };
+      }
+      break;
+
+    case ParameterType.Dictionary:
+      if (typeof value !== 'object' || Array.isArray(value) || value === null) {
+        return {
+          field: paramName,
+          message: `Parameter '${paramName}' must be an object, but received ${actualType}`
+        };
+      }
+      break;
+
+    default:
+      return {
+        field: paramName,
+        message: `Parameter '${paramName}' has unknown expected type: ${String(expectedType)}`
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Get a human-readable description of the actual type
+   * @param value The value to check
+   * @returns String description of the type
+   */
+  private static getActualType(value: any): string {
+    if (value === null) return 'null';
+    if (value === undefined) return 'undefined';
+    if (Array.isArray(value)) return 'array';
+    return typeof value;
+  }
+}