@coinbase-sample/prime-sdk-ts 0.6.2 → 0.6.4

package/dist/shared/dynamicEnumValidation.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumRegistry = exports.DynamicEnumValidationError = void 0;
+exports.setDynamicValidationConfig = setDynamicValidationConfig;
+exports.getDynamicValidationConfig = getDynamicValidationConfig;
+exports.dynamicValidateRequest = dynamicValidateRequest;
+exports.getEnumInfo = getEnumInfo;
+/**
+ * Dynamic enum validation system that automatically discovers and validates
+ * enum fields in request objects without manual service-specific configuration.
+ *
+ * This approach is more scalable and maintainable than manual validation rules.
+ */
+const enumRegistry_1 = require("./enumRegistry");
+Object.defineProperty(exports, "enumRegistry", { enumerable: true, get: function () { return enumRegistry_1.enumRegistry; } });
+const enumValidationCore_1 = require("./enumValidationCore");
+Object.defineProperty(exports, "DynamicEnumValidationError", { enumerable: true, get: function () { return enumValidationCore_1.DynamicEnumValidationError; } });
+// Default configuration
+const defaultConfig = {
+    enabled: true,
+    strict: true,
+    autoNormalize: true,
+    logWarnings: true,
+};
+let currentConfig = Object.assign({}, defaultConfig);
+// Cache for request type analysis to improve performance
+const requestTypeCache = new Map();
+/**
+ * Set global configuration for dynamic enum validation
+ */
+function setDynamicValidationConfig(config) {
+    currentConfig = Object.assign(Object.assign({}, currentConfig), config);
+}
+/**
+ * Get current dynamic validation configuration
+ */
+function getDynamicValidationConfig() {
+    return Object.assign({}, currentConfig);
+}
+/**
+ * Analyze request structure to identify enum fields
+ */
+function analyzeRequestType(request, serviceName) {
+    // Use object structure and service name as cache key
+    const cacheKey = JSON.stringify({
+        structure: Object.keys(request || {})
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = typeof request[key];
+            return acc;
+        }, {}),
+        serviceName: serviceName || 'unknown',
+    });
+    // Return cached result if available
+    const cached = requestTypeCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const enumFields = [];
+    if (!request || typeof request !== 'object') {
+        return enumFields;
+    }
+    Object.entries(request).forEach(([fieldName, value]) => {
+        const fieldInfo = (0, enumValidationCore_1.analyzeField)(fieldName, value, serviceName);
+        if (fieldInfo) {
+            enumFields.push(fieldInfo);
+        }
+    });
+    // Cache the result
+    requestTypeCache.set(cacheKey, enumFields);
+    return enumFields;
+}
+/**
+ * Validate request object and normalize enum values
+ */
+function validateRequestEnums(request, config = currentConfig) {
+    const validatedRequest = Object.assign({}, request);
+    const errors = [];
+    if (!config.enabled) {
+        return { validatedRequest, errors };
+    }
+    const enumFields = analyzeRequestType(request, config.serviceName);
+    enumFields.forEach((fieldInfo) => {
+        const { fieldName, enumName, isArray } = fieldInfo;
+        const fieldValue = request[fieldName];
+        if (fieldValue === undefined || fieldValue === null) {
+            return;
+        }
+        try {
+            const enumObject = enumRegistry_1.enumRegistry.getEnum(enumName);
+            if (!enumObject) {
+                errors.push(`${fieldName}: Enum ${enumName} not found`);
+                return;
+            }
+            if (isArray && Array.isArray(fieldValue)) {
+                // Handle array values
+                const validatedArray = [];
+                for (const item of fieldValue) {
+                    if (typeof item === 'string') {
+                        const validation = (0, enumValidationCore_1.validateEnumValue)(item, enumObject, enumName, fieldName, config);
+                        if (validation.isValid && validation.normalizedValue) {
+                            validatedArray.push(validation.normalizedValue);
+                        }
+                        else if (validation.error) {
+                            if (config.strict) {
+                                throw new enumValidationCore_1.DynamicEnumValidationError(fieldName, item, enumName, Object.values(enumObject), Object.keys(enumObject));
+                            }
+                            else {
+                                if (config.logWarnings) {
+                                    console.warn(`[Prime SDK] Dynamic enum validation warning: ${validation.error}`);
+                                }
+                                validatedArray.push(item); // Keep original value
+                            }
+                        }
+                    }
+                }
+                validatedRequest[fieldName] = validatedArray;
+            }
+            else if (typeof fieldValue === 'string') {
+                // Handle single string values
+                const validation = (0, enumValidationCore_1.validateEnumValue)(fieldValue, enumObject, enumName, fieldName, config);
+                if (validation.isValid && validation.normalizedValue) {
+                    validatedRequest[fieldName] = validation.normalizedValue;
+                }
+                else if (validation.error) {
+                    if (config.strict) {
+                        throw new enumValidationCore_1.DynamicEnumValidationError(fieldName, fieldValue, enumName, Object.values(enumObject), Object.keys(enumObject));
+                    }
+                    else {
+                        if (config.logWarnings) {
+                            console.warn(`[Prime SDK] Dynamic enum validation warning: ${validation.error}`);
+                        }
+                        // Keep original value in non-strict mode
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof enumValidationCore_1.DynamicEnumValidationError) {
+                throw error; // Re-throw enum validation errors
+            }
+            errors.push(`${fieldName}: Unexpected validation error: ${error}`);
+        }
+    });
+    return { validatedRequest, errors };
+}
+/**
+ * Main API: Validate and normalize request with type-safe generics
+ */
+function dynamicValidateRequest(request, config) {
+    const validationConfig = config
+        ? Object.assign(Object.assign({}, currentConfig), config) : currentConfig;
+    const result = validateRequestEnums(request, validationConfig);
+    if (result.errors.length > 0) {
+        throw new enumValidationCore_1.DynamicEnumValidationError('request', 'multiple fields', 'various', [], result.errors);
+    }
+    return result.validatedRequest;
+}
+/**
+ * Get information about discovered enums
+ */
+function getEnumInfo() {
+    const stats = enumRegistry_1.enumRegistry.getStats();
+    return {
+        totalEnums: stats.totalEnums,
+        enumNames: enumRegistry_1.enumRegistry.getAllEnumNames(),
+        enumDetails: enumRegistry_1.enumRegistry.getEnumDetails(),
+    };
+}