Merge pull request #1427 from opencomponents/add-enum

add enum prop for params

Author: ricardo-devis-agullo

src/registry/domain/validators/component-parameters.ts

@@ -7,54 +7,44 @@ const validateParameter = (
 ): boolean => {
   const expected = expectedType.toLowerCase();
 
-  if (expected === 'boolean') {
-    return typeof parameter === 'boolean';
+  switch (expected) {
+    case 'boolean':
+      return typeof parameter === 'boolean';
+    case 'number':
+      return typeof parameter === 'number';
+    case 'string':
+      return typeof parameter === 'string';
+    default:
+      return false;
   }
-  if (expected === 'number') {
-    return typeof parameter === 'number';
-  }
-  if (expected === 'string') {
-    return typeof parameter === 'string';
-  }
-
-  return false;
 };
 
 interface ValidationResult {
   isValid: boolean;
   errors: {
-    mandatory?: Record<string, string>;
-    types?: Record<string, string>;
-    message?: string;
+    mandatory: Record<string, string>;
+    types: Record<string, string>;
+    message: string;
   };
 }
 
 export default function componentParameters(
   requestParameters: Record<string, string | number | boolean>,
   expectedParameters: Record<string, OcParameter> = {}
 ): ValidationResult {
-  const result: ValidationResult = { isValid: true, errors: {} };
-  const mandatoryParameters: string[] = [];
-
-  for (const [expectedParameterName, expectedParameter] of Object.entries(
-    expectedParameters
-  )) {
-    if (expectedParameter.mandatory) {
-      mandatoryParameters.push(expectedParameterName);
-    }
-  }
+  const result: ValidationResult = {
+    isValid: true,
+    errors: { mandatory: {}, types: {}, message: '' }
+  };
+  requestParameters = requestParameters || {};
+  expectedParameters = expectedParameters || {};
+  const mandatoryParameters: string[] = Object.entries(expectedParameters)
+    .filter(([_, expectedParameter]) => expectedParameter.mandatory)
+    .map(([expectedParameterName]) => expectedParameterName);
 
   for (const mandatoryParameterName of mandatoryParameters) {
-    if (
-      typeof requestParameters === 'object' &&
-      // biome-ignore lint/suspicious/noPrototypeBuiltins: hasOwnProperty is fine
-      !requestParameters.hasOwnProperty(mandatoryParameterName)
-    ) {
-      if (!result.errors.mandatory) {
-        result.errors.mandatory = {};
-        result.isValid = false;
-      }
-
+    if (!(mandatoryParameterName in requestParameters)) {
+      result.isValid = false;
       result.errors.mandatory[mandatoryParameterName] =
         strings.errors.registry.MANDATORY_PARAMETER_MISSING_CODE;
     }
@@ -63,21 +53,27 @@ export default function componentParameters(
   for (const [requestParameterName, requestParameter] of Object.entries(
     requestParameters
   )) {
-    if (
-      typeof expectedParameters === 'object' &&
-      // biome-ignore lint/suspicious/noPrototypeBuiltins: hasOwnProperty is fine
-      expectedParameters.hasOwnProperty(requestParameterName)
-    ) {
+    if (expectedParameters[requestParameterName]) {
       const expectedType = expectedParameters[requestParameterName].type;
 
       if (!validateParameter(requestParameter, expectedType)) {
-        if (!result.errors.types) {
-          result.errors.types = {};
-          result.isValid = false;
-        }
-
+        result.isValid = false;
         result.errors.types[requestParameterName] =
           strings.errors.registry.PARAMETER_WRONG_FORMAT_CODE;
+        continue; // Skip enum validation if type validation fails
+      }
+
+      const expectedValues = expectedParameters[requestParameterName].enum;
+      if (
+        expectedValues &&
+        !(expectedValues as any).includes(requestParameter)
+      ) {
+        result.isValid = false;
+        result.errors.types[requestParameterName] =
+          strings.errors.registry.PARAMETER_WRONG_VALUE(
+            requestParameterName,
+            expectedValues as string[]
+          );
       }
     }
   }

src/resources/index.ts

@@ -149,6 +149,9 @@ export default {
       PARAMETER_WRONG_FORMAT: (parameters: string): string =>
         `Parameters are not correctly formatted: ${parameters}`,
       PARAMETER_WRONG_FORMAT_CODE: 'wrong type',
+      PARAMETER_WRONG_VALUE: (parameter: string, values: string[]): string =>
+        `Parameter ${parameter} is not a valid value. Allowed values are: ${values.join(', ')}`,
+      PARAMETER_WRONG_VALUE_CODE: 'wrong value',
       PLUGIN_NOT_IMPLEMENTED: (plugins: string): string =>
         `registry does not implement plugins: ${plugins}`,
       PLUGIN_NOT_VALID: (plugin: string): string =>

src/types.ts

@@ -59,6 +59,16 @@ export interface OcParameter {
   description?: string;
   example?: string;
   mandatory?: boolean;
+  /**
+   * You can optionally restrict the values of the parameter to a specific set of values.
+   * @example
+   * ```ts
+   * {
+   *   type: 'string',
+   *   enum: ['foo', 'bar', 'baz']
+   * }
+   */
+  enum?: string[] | number[] | boolean[];
   type: 'string' | 'boolean' | 'number';
 }