@chargebee/chargebee-apps-shared 0.0.2

package/dist/validator/iparam-defns-validator.js

@@ -0,0 +1,291 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IparamDefnsValidator = void 0;
+const common_1 = require("../types/common");
+const iparam_constants_1 = require("./iparam-constants");
+const iparams_inputs_validator_1 = require("./iparams-inputs-validator");
+const validatorUtils = __importStar(require("./validator-utils"));
+/**
+ * Validator for iparamDefns
+ * Validates the sectioned iparams.json schema
+ */
+class IparamDefnsValidator {
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+        this.inputsValidator = new iparams_inputs_validator_1.IparamInputsValidator(fileSystem);
+    }
+    /**
+     * Validates and loads the iparamDefns from a file
+     * @param {string} path - Path to the iparams.json file
+     * @returns {IparamDefns} The validated iparamDefns
+     * @throws {Error} If the iparamDefns is invalid or cannot be read
+     */
+    validateAndGetIparamDefnsFile(path) {
+        validatorUtils.ensureFileExists(this.fileSystem, path);
+        try {
+            const iparamDefns = JSON.parse(this.fileSystem.readFileSync(path, 'utf8'));
+            try {
+                this.validate(iparamDefns);
+                return iparamDefns;
+            }
+            catch (validationError) {
+                const err = new Error(validationError.message);
+                err.rawContent = iparamDefns;
+                throw err;
+            }
+        }
+        catch (error) {
+            if (error.rawContent !== undefined) {
+                throw error;
+            }
+            if (error instanceof SyntaxError) {
+                throw new Error(`Failed to parse ${iparam_constants_1.IPARAMS_JSON_FILENAME}: ${error.message}`);
+            }
+            throw new Error(`Failed to read ${iparam_constants_1.IPARAMS_JSON_FILENAME}: ${error.message}`);
+        }
+    }
+    /**
+     * Validates an iparamDefns object
+     * @param {IparamDefns} iparamDefns - The iparamDefns object to validate
+     * @throws {Error} If the iparamDefns is invalid
+     */
+    validate(iparamDefns) {
+        if (!iparamDefns || typeof iparamDefns !== 'object' || Array.isArray(iparamDefns)) {
+            throw new Error(`${iparam_constants_1.IPARAMS_JSON_FILENAME} must be an object`);
+        }
+        this.rejectUnknownKeys(iparamDefns, iparam_constants_1.IPARAMS_ROOT_ALLOWED_KEYS, iparam_constants_1.IPARAMS_JSON_FILENAME);
+        if (!Object.prototype.hasOwnProperty.call(iparamDefns, iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_LABEL)) {
+            return;
+        }
+        const installationParameters = iparamDefns.installation_parameters;
+        if (!installationParameters || typeof installationParameters !== 'object' || Array.isArray(installationParameters)) {
+            throw new Error(`${iparam_constants_1.IPARAMS_JSON_FILENAME} must include ${iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_LABEL} as an object containing a ${iparam_constants_1.IPARAMS_SECTIONS_LABEL} array`);
+        }
+        this.rejectUnknownKeys(installationParameters, iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_ALLOWED_KEYS, iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_LABEL);
+        if (!Object.prototype.hasOwnProperty.call(installationParameters, iparam_constants_1.IPARAMS_SECTIONS_LABEL)) {
+            throw new Error(`${iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_LABEL} must include ${iparam_constants_1.IPARAMS_SECTIONS_LABEL} in ${iparam_constants_1.IPARAMS_JSON_FILENAME}`);
+        }
+        const sections = installationParameters.sections;
+        if (!Array.isArray(sections)) {
+            throw new Error(`${iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_LABEL}.${iparam_constants_1.IPARAMS_SECTIONS_LABEL} must be an array of section objects`);
+        }
+        if (sections.length === 0) {
+            throw new Error(`${iparam_constants_1.IPARAMS_INSTALLATION_PARAMETERS_LABEL}.${iparam_constants_1.IPARAMS_SECTIONS_LABEL} must contain at least one section`);
+        }
+        for (let i = 0; i < sections.length; i++) {
+            this.validateSection(sections[i], i);
+        }
+        const totalParamCount = sections.reduce((count, section) => count + section.parameters.length, 0);
+        if (totalParamCount > iparam_constants_1.IPARAMS_MAX_COUNT) {
+            throw new Error(`${iparam_constants_1.IPARAMS_JSON_FILENAME} cannot define more than ${iparam_constants_1.IPARAMS_MAX_COUNT} parameters (found ${totalParamCount})`);
+        }
+        const sectionNames = sections.map((section) => section.name.trim());
+        const seenSectionNames = new Set();
+        const duplicateSections = [];
+        for (const name of sectionNames) {
+            if (seenSectionNames.has(name))
+                duplicateSections.push(name);
+            else
+                seenSectionNames.add(name);
+        }
+        if (duplicateSections.length > 0) {
+            throw new Error(`Duplicate section names found: ${duplicateSections.join(', ')}`);
+        }
+        for (const section of sections) {
+            const paramNames = section.parameters.map((param) => param.name.trim());
+            const seenParamNames = new Set();
+            const duplicateParams = [];
+            for (const name of paramNames) {
+                if (seenParamNames.has(name))
+                    duplicateParams.push(name);
+                else
+                    seenParamNames.add(name);
+            }
+            if (duplicateParams.length > 0) {
+                throw new Error(`Duplicate parameter names found in section "${section.name}": ${duplicateParams.join(', ')}`);
+            }
+        }
+    }
+    /**
+     * Validates a single section definition
+     * @param {any} section - The section definition to validate
+     * @param {number} index - The index of the section in the array (for error messages)
+     * @throws {Error} If the section is invalid
+     */
+    validateSection(section, index) {
+        if (!section || typeof section !== 'object') {
+            throw new Error(`Section at index ${index} must be an object`);
+        }
+        const sectionName = this.validateSectionName(section, index);
+        this.requireNonEmptyStringField(section, sectionName, 'display_name', iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.DISPLAY_NAME, 'Section');
+        this.requireNonEmptyStringField(section, sectionName, 'description', iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.DESCRIPTION, 'Section');
+        const parameters = section['parameters'];
+        if (!Array.isArray(parameters)) {
+            throw new Error(`Section "${sectionName}": "parameters" must be an array`);
+        }
+        if (parameters.length === 0) {
+            throw new Error(`Section "${sectionName}": "parameters" must contain at least one parameter`);
+        }
+        for (let i = 0; i < parameters.length; i++) {
+            this.validateParameter(parameters[i], sectionName, i);
+        }
+    }
+    /**
+     * Validates a single parameter definition
+     * @param {any} param - The parameter definition to validate
+     * @param {string} sectionName - Parent section name for error messages
+     * @param {number} index - The index of the parameter in the section (for error messages)
+     * @throws {Error} If the parameter is invalid
+     */
+    validateParameter(param, sectionName, index) {
+        if (!param || typeof param !== 'object') {
+            throw new Error(`Section "${sectionName}": parameter at index ${index} must be an object`);
+        }
+        const paramName = this.validateParamName(param, sectionName, index);
+        const sectionDotParam = `${sectionName}.${paramName}`;
+        this.requireNonEmptyStringField(param, sectionDotParam, 'display_name', iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.DISPLAY_NAME);
+        this.requireNonEmptyStringField(param, sectionDotParam, 'description', iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.DESCRIPTION);
+        this.validateType(param, sectionDotParam);
+        if (param.required !== undefined && typeof param.required !== 'boolean') {
+            throw new Error(`Parameter "${sectionDotParam}": "required" must be a boolean`);
+        }
+        this.validateOptions(param, sectionDotParam);
+        if (param.type === 'SECRET' && param.default !== undefined && param.default !== null) {
+            throw new Error(`Parameter "${sectionDotParam}": SECRET type cannot have a default value`);
+        }
+        this.validateDefaultValue(param, sectionDotParam);
+    }
+    requireNonEmptyStringField(entity, entityName, fieldName, maxLength, entityLabel = 'Parameter') {
+        const value = entity[fieldName];
+        if (!validatorUtils.isNonEmptyString(value)) {
+            throw new Error(`${entityLabel} "${entityName}": "${fieldName}" must be a non-empty string`);
+        }
+        const trimmed = value.trim();
+        if (maxLength !== undefined && trimmed.length > maxLength) {
+            throw new Error(`${entityLabel} "${entityName}": "${fieldName}" cannot exceed ${maxLength} characters`);
+        }
+    }
+    rejectUnknownKeys(entity, allowedKeys, entityLabel) {
+        for (const key of Object.keys(entity)) {
+            if (!allowedKeys.includes(key)) {
+                throw new Error(`${entityLabel} must only contain ${allowedKeys.map((k) => `"${k}"`).join(', ')}`);
+            }
+        }
+    }
+    validateSectionName(section, index) {
+        const name = section['name'];
+        if (!validatorUtils.isNonEmptyString(name)) {
+            throw new Error(`Section at index ${index}: "name" must be a non-empty string`);
+        }
+        const sectionName = name.trim();
+        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(sectionName)) {
+            throw new Error(`Section "${sectionName}": "name" can only contain letters, numbers, underscores, and hyphens, and must start with a letter or underscore`);
+        }
+        if (sectionName.length > iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.NAME) {
+            throw new Error(`Section "${sectionName}": "name" must be between 1 and ${iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.NAME} characters`);
+        }
+        return sectionName;
+    }
+    validateParamName(param, sectionName, index) {
+        const name = param['name'];
+        if (!validatorUtils.isNonEmptyString(name)) {
+            throw new Error(`Section "${sectionName}": parameter at index ${index}: "name" must be a non-empty string`);
+        }
+        const paramName = name.trim();
+        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(paramName)) {
+            throw new Error(`Parameter "${sectionName}.${paramName}": "name" can only contain letters, numbers, underscores, and hyphens, and must start with a letter or underscore`);
+        }
+        if (paramName.length > iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.NAME) {
+            throw new Error(`Parameter "${sectionName}.${paramName}": "name" must be between 1 and ${iparam_constants_1.IPARAM_DEFN_MAX_LENGTHS.NAME} characters`);
+        }
+        return paramName;
+    }
+    validateType(param, sectionDotParam) {
+        const type = param['type'];
+        if (!type || !common_1.VALID_IPARAM_TYPES.includes(type)) {
+            throw new Error(`Parameter "${sectionDotParam}": "type" must be one of: ${common_1.VALID_IPARAM_TYPES.join(', ')}`);
+        }
+    }
+    validateOptions(param, sectionDotParam) {
+        const paramType = param['type'];
+        if (paramType !== 'DROPDOWN' && paramType !== 'MULTISELECT_DROPDOWN') {
+            if (Object.prototype.hasOwnProperty.call(param, 'options')) {
+                throw new Error(`Parameter "${sectionDotParam}": "options" is only allowed for DROPDOWN and MULTISELECT_DROPDOWN types`);
+            }
+            return;
+        }
+        const options = param['options'];
+        if (!options || !Array.isArray(options) || options.length === 0) {
+            throw new Error(`Parameter "${sectionDotParam}": "options" is required and must be a non-empty array of strings for ${paramType} type`);
+        }
+        if (options.length > iparam_constants_1.OPTIONS_LIMITS.MAX_COUNT) {
+            throw new Error(`Parameter "${sectionDotParam}": "options" cannot exceed ${iparam_constants_1.OPTIONS_LIMITS.MAX_COUNT} items for ${paramType} type`);
+        }
+        const seenTrimmedOptions = new Set();
+        for (let i = 0; i < options.length; i++) {
+            if (typeof options[i] !== 'string') {
+                throw new Error(`Parameter "${sectionDotParam}": option at index ${i} must be a string`);
+            }
+            const optionStr = options[i].trim();
+            if (optionStr === '') {
+                throw new Error(`Parameter "${sectionDotParam}": option at index ${i} cannot be an empty string`);
+            }
+            if (seenTrimmedOptions.has(optionStr)) {
+                throw new Error(`Parameter "${sectionDotParam}": "options" must not contain duplicate entries`);
+            }
+            seenTrimmedOptions.add(optionStr);
+            if (optionStr.length > iparam_constants_1.OPTIONS_LIMITS.MAX_OPTION_LENGTH) {
+                throw new Error(`Parameter "${sectionDotParam}": option at index ${i} cannot exceed ${iparam_constants_1.OPTIONS_LIMITS.MAX_OPTION_LENGTH} characters`);
+            }
+        }
+    }
+    validateDefaultValue(param, sectionDotParam) {
+        const defaultValue = param['default'];
+        if (defaultValue === undefined || defaultValue === null)
+            return;
+        if (typeof defaultValue === 'string' && defaultValue.trim() === '') {
+            throw new Error(`Parameter "${sectionDotParam}": default value cannot be an empty string. Either remove the "default" key, set it to null, or provide a non-empty value.`);
+        }
+        try {
+            this.inputsValidator.validateParamValue(param, defaultValue, sectionDotParam);
+        }
+        catch (error) {
+            const msg = error.message.replace(/\bvalue\b/g, 'default value');
+            throw new Error(msg);
+        }
+    }
+}
+exports.IparamDefnsValidator = IparamDefnsValidator;

package/dist/validator/iparams-inputs-validator.d.ts

@@ -0,0 +1,62 @@
+import { CBFileSystem } from '../node/file-system';
+import { IparamDefn, IparamInputs, IparamDefns, IparamValue } from '../types/common';
+/**
+ * Validator for parameter inputs
+ * Validates input values against the sectioned iparamDefns
+ */
+export declare class IparamInputsValidator {
+    private fileSystem;
+    constructor(fileSystem: CBFileSystem);
+    /**
+     * Validates whether the value counts as a provided input.
+     * Not whether it is allowed by iparam definitions—that is handled by {@link IparamInputsValidator.validateInputs}.
+     */
+    static isProvidedIparamInputValue(value: IparamValue | undefined | null): value is IparamValue;
+    /**
+     * Validates and loads the iparam inputs from a file (no validation against iparamDefns).
+     * Only ensures the file is valid JSON and the root value is an object.
+     * @param {string} path - Path to the iparams.local.json file
+     * @returns {IparamInputs} The loaded inputs
+     * @throws {Error} If the file does not exist, cannot be read or parsed, or root is not an object
+     */
+    validateAndGetIparamInputsFile(path: string): IparamInputs;
+    /**
+     * Ensures the inputs value is a plain object
+     * @param {any} inputs - The value to check
+     * @throws {Error} If inputs is not a plain object
+     */
+    ensureInputsIsObject(inputs: any): void;
+    /**
+     * Validates inputs against the iparamDefns (without applying defaults)
+     * Only validates provided values, does not include defaults in the result
+     * @param {IparamInputs} inputs - The input values to validate
+     * @param {IparamDefns} iparamDefns - The iparamDefns
+     * @returns {IparamInputs} The validated inputs (only provided values, no defaults)
+     * @throws {Error} If validation fails
+     * @throws {MissingRequiredParamsError} If required parameters are missing
+     */
+    validateInputs(inputs: IparamInputs, iparamDefns: IparamDefns): IparamInputs;
+    /**
+     * Validates a single parameter value against its parameter definition.
+     * @param {IparamDefn} param - The parameter definition
+     * @param {any} value - The value to validate
+     * @param {string} [sectionDotParam] - Optional section.param identifier for error messages (e.g. processing_fee_configuration.fee_percentage)
+     * @throws {Error} If the value is invalid
+     */
+    validateParamValue(param: IparamDefn, value: unknown, sectionDotParam?: string): void;
+    /**
+     * Requires value to be a non-empty string, optionally with max length.
+     * @throws {Error} If not a string, empty after trim, or exceeds maxLength
+     */
+    private requireNonEmptyString;
+    /**
+     * Requires value to be one of the allowed options.
+     */
+    private requireInOptions;
+    private validateNumber;
+    private validateBoolean;
+    private validateUrl;
+    private validateDate;
+    private validateDropdown;
+    private validateMultiselectDropdown;
+}

package/dist/validator/iparams-inputs-validator.js

@@ -0,0 +1,289 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IparamInputsValidator = void 0;
+const errors_1 = require("../errors");
+const internal_logger_1 = require("../logger/internal-logger");
+const iparam_constants_1 = require("./iparam-constants");
+const validatorUtils = __importStar(require("./validator-utils"));
+/**
+ * Validator for parameter inputs
+ * Validates input values against the sectioned iparamDefns
+ */
+class IparamInputsValidator {
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+    }
+    /**
+     * Validates whether the value counts as a provided input.
+     * Not whether it is allowed by iparam definitions—that is handled by {@link IparamInputsValidator.validateInputs}.
+     */
+    static isProvidedIparamInputValue(value) {
+        if (value === undefined || value === null)
+            return false;
+        if (typeof value === 'string')
+            return value.trim() !== '';
+        if (Array.isArray(value))
+            return value.length > 0;
+        return true;
+    }
+    /**
+     * Validates and loads the iparam inputs from a file (no validation against iparamDefns).
+     * Only ensures the file is valid JSON and the root value is an object.
+     * @param {string} path - Path to the iparams.local.json file
+     * @returns {IparamInputs} The loaded inputs
+     * @throws {Error} If the file does not exist, cannot be read or parsed, or root is not an object
+     */
+    validateAndGetIparamInputsFile(path) {
+        validatorUtils.ensureFileExists(this.fileSystem, path);
+        try {
+            const inputs = JSON.parse(this.fileSystem.readFileSync(path, 'utf8'));
+            if (typeof inputs !== 'object' || Array.isArray(inputs)) {
+                throw new Error('iparams.local.json must be an object');
+            }
+            return inputs;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Failed to parse iparams.local.json: ${error.message}`);
+            }
+            throw new Error(`Failed to read iparams.local.json: ${error.message}`);
+        }
+    }
+    /**
+     * Ensures the inputs value is a plain object
+     * @param {any} inputs - The value to check
+     * @throws {Error} If inputs is not a plain object
+     */
+    ensureInputsIsObject(inputs) {
+        if (inputs === null || typeof inputs !== 'object' || Array.isArray(inputs)) {
+            throw new Error('Inputs must be an object');
+        }
+    }
+    /**
+     * Validates inputs against the iparamDefns (without applying defaults)
+     * Only validates provided values, does not include defaults in the result
+     * @param {IparamInputs} inputs - The input values to validate
+     * @param {IparamDefns} iparamDefns - The iparamDefns
+     * @returns {IparamInputs} The validated inputs (only provided values, no defaults)
+     * @throws {Error} If validation fails
+     * @throws {MissingRequiredParamsError} If required parameters are missing
+     */
+    validateInputs(inputs, iparamDefns) {
+        this.ensureInputsIsObject(inputs);
+        const validatedInputs = {};
+        const missingRequired = [];
+        const sections = iparamDefns.installation_parameters?.sections ?? [];
+        const sectionByName = new Map(sections.map((section) => [section.name, section]));
+        for (const section of sections) {
+            const sectionInputs = inputs[section.name];
+            if (sectionInputs !== undefined && sectionInputs !== null) {
+                if (typeof sectionInputs !== 'object' || Array.isArray(sectionInputs)) {
+                    throw new Error(`Section "${section.name}": inputs must be an object`);
+                }
+            }
+            const sectionObject = {};
+            for (const param of section.parameters) {
+                const sectionDotParam = `${section.name}.${param.name}`;
+                const value = sectionInputs?.[param.name];
+                if (IparamInputsValidator.isProvidedIparamInputValue(value)) {
+                    this.validateParamValue(param, value, sectionDotParam);
+                    sectionObject[param.name] = value;
+                }
+                else if (param.required && (param.default === undefined || param.default === null)) {
+                    missingRequired.push(sectionDotParam);
+                }
+            }
+            if (Object.keys(sectionObject).length > 0) {
+                validatedInputs[section.name] = sectionObject;
+            }
+        }
+        if (missingRequired.length > 0) {
+            throw new errors_1.MissingRequiredParamsError(missingRequired);
+        }
+        for (const [sectionName, sectionInputs] of Object.entries(inputs)) {
+            const section = sectionByName.get(sectionName);
+            if (!section) {
+                internal_logger_1.__logger.warn(`Unknown section "${sectionName}" will be ignored`);
+                continue;
+            }
+            if (sectionInputs === undefined || sectionInputs === null)
+                continue;
+            if (typeof sectionInputs !== 'object' || Array.isArray(sectionInputs))
+                continue;
+            const knownParamNames = new Set(section.parameters.map((param) => param.name));
+            for (const key of Object.keys(sectionInputs)) {
+                if (!knownParamNames.has(key)) {
+                    internal_logger_1.__logger.warn(`Unknown parameter "${sectionName}.${key}" will be ignored`);
+                }
+            }
+        }
+        return validatedInputs;
+    }
+    /**
+     * Validates a single parameter value against its parameter definition.
+     * @param {IparamDefn} param - The parameter definition
+     * @param {any} value - The value to validate
+     * @param {string} [sectionDotParam] - Optional section.param identifier for error messages (e.g. processing_fee_configuration.fee_percentage)
+     * @throws {Error} If the value is invalid
+     */
+    validateParamValue(param, value, sectionDotParam = param.name) {
+        switch (param.type) {
+            case 'NUMBER':
+                this.validateNumber(sectionDotParam, value);
+                break;
+            case 'TEXT':
+                this.requireNonEmptyString(sectionDotParam, value, iparam_constants_1.IPARAM_VALUE_MAX_LENGTHS.TEXT);
+                break;
+            case 'SECRET':
+                this.requireNonEmptyString(sectionDotParam, value, iparam_constants_1.IPARAM_VALUE_MAX_LENGTHS.SECRET);
+                break;
+            case 'BOOLEAN':
+                this.validateBoolean(sectionDotParam, value);
+                break;
+            case 'URL':
+                this.validateUrl(sectionDotParam, value);
+                break;
+            case 'DATE':
+                this.validateDate(sectionDotParam, value);
+                break;
+            case 'DROPDOWN':
+                this.validateDropdown(param, value, sectionDotParam);
+                break;
+            case 'MULTISELECT_DROPDOWN':
+                this.validateMultiselectDropdown(param, value, sectionDotParam);
+                break;
+            default: {
+                const exhaustive = param.type;
+                throw new Error(`Parameter "${sectionDotParam}": unknown type "${exhaustive}"`);
+            }
+        }
+    }
+    /**
+     * Requires value to be a non-empty string, optionally with max length.
+     * @throws {Error} If not a string, empty after trim, or exceeds maxLength
+     */
+    requireNonEmptyString(paramName, value, maxLength) {
+        if (!validatorUtils.isNonEmptyString(value)) {
+            throw new Error(`Parameter "${paramName}": value must be a non-empty string`);
+        }
+        if (maxLength !== undefined && value.length > maxLength) {
+            throw new Error(`Parameter "${paramName}": value cannot exceed ${maxLength} characters`);
+        }
+    }
+    /**
+     * Requires value to be one of the allowed options.
+     */
+    requireInOptions(paramName, value, options) {
+        if (options.length === 0 || options.includes(value))
+            return;
+        throw new Error(`Parameter "${paramName}": value must be one of: ${options.join(', ')}`);
+    }
+    validateNumber(paramName, value) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new Error(`Parameter "${paramName}": value must be a finite number`);
+        }
+        if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+            throw new Error(`Parameter "${paramName}": value must be within the range of ${Number.MIN_SAFE_INTEGER} to ${Number.MAX_SAFE_INTEGER}`);
+        }
+    }
+    validateBoolean(paramName, value) {
+        if (typeof value !== 'boolean') {
+            throw new Error(`Parameter "${paramName}": value must be a boolean`);
+        }
+    }
+    validateUrl(paramName, value) {
+        this.requireNonEmptyString(paramName, value, iparam_constants_1.IPARAM_VALUE_MAX_LENGTHS.URL);
+        let parsed;
+        try {
+            parsed = new URL(value);
+        }
+        catch {
+            throw new Error(`Parameter "${paramName}": value must be a valid URL`);
+        }
+        if (!iparam_constants_1.IPARAM_URL_ALLOWED_PROTOCOLS.some((p) => p === parsed.protocol)) {
+            throw new Error(`Parameter "${paramName}": value must be a valid URL with protocol ${iparam_constants_1.IPARAM_URL_ALLOWED_PROTOCOLS.join(' or ')}`);
+        }
+    }
+    validateDate(paramName, value) {
+        this.requireNonEmptyString(paramName, value, iparam_constants_1.IPARAM_VALUE_MAX_LENGTHS.DATE);
+        const str = value;
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(str)) {
+            throw new Error(`Parameter "${paramName}": value must be a valid date in YYYY-MM-DD format (e.g., 2025-12-31)`);
+        }
+        const [y, m, d] = str.split('-').map(Number);
+        const dateObj = new Date(Date.UTC(y, m - 1, d));
+        if (isNaN(dateObj.getTime()) ||
+            dateObj.getUTCFullYear() !== y ||
+            dateObj.getUTCMonth() !== m - 1 ||
+            dateObj.getUTCDate() !== d) {
+            throw new Error(`Parameter "${paramName}": value must be a valid date in YYYY-MM-DD format (e.g., 2025-12-31)`);
+        }
+    }
+    validateDropdown(param, value, sectionDotParam) {
+        if (typeof value !== 'string') {
+            throw new Error(`Parameter "${sectionDotParam}": value must be a string for DROPDOWN type`);
+        }
+        this.requireNonEmptyString(sectionDotParam, value);
+        if (param.options)
+            this.requireInOptions(sectionDotParam, value, param.options);
+    }
+    validateMultiselectDropdown(param, value, sectionDotParam) {
+        if (!Array.isArray(value)) {
+            throw new Error(`Parameter "${sectionDotParam}": value must be an array of strings for MULTISELECT_DROPDOWN type`);
+        }
+        if (value.length === 0) {
+            throw new Error(`Parameter "${sectionDotParam}": value must be a non-empty array of strings for MULTISELECT_DROPDOWN type`);
+        }
+        const seenTrimmed = new Set();
+        for (let i = 0; i < value.length; i++) {
+            try {
+                this.requireNonEmptyString(sectionDotParam, value[i]);
+                if (param.options)
+                    this.requireInOptions(sectionDotParam, value[i], param.options);
+            }
+            catch (error) {
+                const msg = error.message.replace(/\bvalue\b/g, `value array item at index ${i}`);
+                throw new Error(msg);
+            }
+            const trimmed = value[i].trim();
+            if (seenTrimmed.has(trimmed)) {
+                throw new Error(`Parameter "${sectionDotParam}": multiselect value must not contain duplicate entries`);
+            }
+            seenTrimmed.add(trimmed);
+        }
+    }
+}
+exports.IparamInputsValidator = IparamInputsValidator;