@brightchain/brightchain-lib 0.1.5 → 0.1.7

package/src/lib/utils/validator.js

@@ -0,0 +1,256 @@
+"use strict";
+/**
+ * Validator Utility Class
+ *
+ * Provides comprehensive input validation utilities for BrightChain services.
+ * All validation methods throw EnhancedValidationError with descriptive messages
+ * when validation fails.
+ *
+ * @remarks
+ * - Use these validators at service boundaries to catch invalid inputs early
+ * - All validators include optional context for better error messages
+ * - Validators are designed to be composable and reusable
+ *
+ * @example
+ * ```typescript
+ * // Validate block parameters
+ * Validator.validateBlockSize(params.blockSize, 'calculateCapacity');
+ * Validator.validateBlockType(params.blockType, 'calculateCapacity');
+ * Validator.validateEncryptionType(params.encryptionType, 'calculateCapacity');
+ *
+ * // Validate required fields
+ * Validator.validateRequired(params.cbl, 'cbl', 'ExtendedCBL');
+ * Validator.validateNotEmpty(params.cbl.fileName, 'fileName', 'ExtendedCBL');
+ * ```
+ *
+ * @see Requirements 5.1, 5.2, 5.3, 5.5, 5.6, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 12.7
+ * @module utils/validator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const constants_1 = require("../constants");
+const blockEncryptionType_1 = require("../enumerations/blockEncryptionType");
+const blockSize_1 = require("../enumerations/blockSize");
+const blockType_1 = require("../enumerations/blockType");
+const enhancedValidationError_1 = require("../errors/enhancedValidationError");
+/**
+ * Validation utilities for common patterns across BrightChain services.
+ *
+ * This class provides static methods for validating:
+ * - Block sizes (enum validation)
+ * - Block types (enum validation)
+ * - Encryption types (enum validation)
+ * - Recipient counts (range validation with encryption type context)
+ * - Required fields (null/undefined checks)
+ * - Non-empty strings (whitespace-only checks)
+ *
+ * @remarks
+ * All validation methods follow a consistent pattern:
+ * 1. Check the value against valid options
+ * 2. Throw EnhancedValidationError with field name and context if invalid
+ * 3. Return void if valid (or use type assertion for validateRequired)
+ *
+ * @example
+ * ```typescript
+ * // In a service method
+ * public processBlock(params: IBlockParams): void {
+ *   // Validate all inputs at the start
+ *   Validator.validateBlockSize(params.blockSize, 'processBlock');
+ *   Validator.validateBlockType(params.blockType, 'processBlock');
+ *
+ *   // Now safe to proceed with validated inputs
+ *   // ...
+ * }
+ * ```
+ *
+ * @see Requirements 5.1, 5.2, 5.3, 5.5, 5.6
+ */
+class Validator {
+    /**
+     * Validate that a block size is a valid BlockSize enum value.
+     *
+     * @param blockSize - The block size to validate
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the block size is not a valid BlockSize enum value
+     *
+     * @remarks
+     * - BlockSize.Unknown (0) is considered invalid for actual use
+     * - Only values in validBlockSizes array are accepted
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateBlockSize(BlockSize.Medium, 'calculateCapacity');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateBlockSize(999 as BlockSize, 'calculateCapacity');
+     * Validator.validateBlockSize(BlockSize.Unknown, 'calculateCapacity');
+     * ```
+     *
+     * @see Requirements 5.1, 12.3
+     */
+    static validateBlockSize(blockSize, context) {
+        if (!blockSize_1.validBlockSizes.includes(blockSize)) {
+            throw new enhancedValidationError_1.EnhancedValidationError('blockSize', `Invalid block size: ${blockSize}. Valid sizes are: ${blockSize_1.validBlockSizes.join(', ')}`, { blockSize, validSizes: [...blockSize_1.validBlockSizes], context });
+        }
+    }
+    /**
+     * Validate that a block type is a valid BlockType enum value.
+     *
+     * @param blockType - The block type to validate
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the block type is not a valid BlockType enum value
+     *
+     * @remarks
+     * - BlockType.Unknown (-1) is considered invalid for actual use
+     * - All other BlockType enum values are valid
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateBlockType(BlockType.RawData, 'processBlock');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateBlockType(999 as BlockType, 'processBlock');
+     * Validator.validateBlockType(BlockType.Unknown, 'processBlock');
+     * ```
+     *
+     * @see Requirements 5.1, 12.4
+     */
+    static validateBlockType(blockType, context) {
+        const validBlockTypes = Object.values(blockType_1.BlockType).filter((v) => typeof v === 'number' && v !== blockType_1.BlockType.Unknown);
+        if (!validBlockTypes.includes(blockType)) {
+            throw new enhancedValidationError_1.EnhancedValidationError('blockType', `Invalid block type: ${blockType}`, { blockType, validTypes: validBlockTypes, context });
+        }
+    }
+    /**
+     * Validate that an encryption type is a valid BlockEncryptionType enum value.
+     *
+     * @param encryptionType - The encryption type to validate
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the encryption type is not a valid BlockEncryptionType enum value
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateEncryptionType(BlockEncryptionType.SingleRecipient, 'encrypt');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateEncryptionType(999 as BlockEncryptionType, 'encrypt');
+     * ```
+     *
+     * @see Requirements 5.1, 12.5
+     */
+    static validateEncryptionType(encryptionType, context) {
+        const validEncryptionTypes = Object.values(blockEncryptionType_1.BlockEncryptionType).filter((v) => typeof v === 'number');
+        if (!validEncryptionTypes.includes(encryptionType)) {
+            throw new enhancedValidationError_1.EnhancedValidationError('encryptionType', `Invalid encryption type: ${encryptionType}`, { encryptionType, validTypes: validEncryptionTypes, context });
+        }
+    }
+    /**
+     * Validate recipient count for multi-recipient encryption.
+     *
+     * @param recipientCount - The number of recipients (may be undefined for non-multi-recipient)
+     * @param encryptionType - The encryption type being used
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If recipient count is invalid for the encryption type
+     *
+     * @remarks
+     * - For MultiRecipient encryption, recipientCount must be at least 1
+     * - For MultiRecipient encryption, recipientCount cannot exceed ECIES.MULTIPLE.MAX_RECIPIENTS
+     * - For other encryption types, recipientCount is ignored
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateRecipientCount(5, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * Validator.validateRecipientCount(undefined, BlockEncryptionType.SingleRecipient, 'encrypt');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateRecipientCount(0, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * Validator.validateRecipientCount(undefined, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * Validator.validateRecipientCount(1000, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * ```
+     *
+     * @see Requirements 5.3, 12.6
+     */
+    static validateRecipientCount(recipientCount, encryptionType, context) {
+        if (encryptionType === blockEncryptionType_1.BlockEncryptionType.MultiRecipient) {
+            if (recipientCount === undefined || recipientCount < 1) {
+                throw new enhancedValidationError_1.EnhancedValidationError('recipientCount', 'Recipient count must be at least 1 for multi-recipient encryption', { recipientCount, encryptionType, context });
+            }
+            const maxRecipients = constants_1.ECIES.MULTIPLE.MAX_RECIPIENTS;
+            if (recipientCount > maxRecipients) {
+                throw new enhancedValidationError_1.EnhancedValidationError('recipientCount', `Recipient count cannot exceed ${maxRecipients}`, { recipientCount, maxRecipients, encryptionType, context });
+            }
+        }
+    }
+    /**
+     * Validate that a required field is present (not null or undefined).
+     *
+     * @param value - The value to check
+     * @param fieldName - The name of the field being validated
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the value is null or undefined
+     *
+     * @remarks
+     * This method uses TypeScript's assertion signature to narrow the type
+     * after validation, allowing safe access to the value.
+     *
+     * @example
+     * ```typescript
+     * // Type narrowing example
+     * function processData(data: string | undefined): void {
+     *   Validator.validateRequired(data, 'data', 'processData');
+     *   // TypeScript now knows data is string, not undefined
+     *   console.log(data.length);
+     * }
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateRequired(undefined, 'config', 'initialize');
+     * Validator.validateRequired(null, 'user', 'authenticate');
+     * ```
+     *
+     * @see Requirements 5.2, 5.6
+     */
+    static validateRequired(value, fieldName, context) {
+        if (value === undefined || value === null) {
+            throw new enhancedValidationError_1.EnhancedValidationError(fieldName, `${fieldName} is required`, {
+                context,
+            });
+        }
+    }
+    /**
+     * Validate that a string is not empty or whitespace-only.
+     *
+     * @param value - The string value to check
+     * @param fieldName - The name of the field being validated
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the value is empty or contains only whitespace
+     *
+     * @remarks
+     * - Empty strings ('') are invalid
+     * - Whitespace-only strings ('   ') are invalid
+     * - Strings with leading/trailing whitespace but content are valid
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateNotEmpty('hello', 'name', 'createUser');
+     * Validator.validateNotEmpty('  hello  ', 'name', 'createUser'); // Valid - has content
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateNotEmpty('', 'name', 'createUser');
+     * Validator.validateNotEmpty('   ', 'name', 'createUser');
+     * ```
+     *
+     * @see Requirements 5.2, 5.6, 12.7
+     */
+    static validateNotEmpty(value, fieldName, context) {
+        if (!value || value.trim().length === 0) {
+            throw new enhancedValidationError_1.EnhancedValidationError(fieldName, `${fieldName} cannot be empty`, { context });
+        }
+    }
+}
+exports.Validator = Validator;
+//# sourceMappingURL=validator.js.map

package/src/lib/utils/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/utils/validator.ts"],"names":[],"mappings":"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"}

package/src/lib/enumerations/stringLanguages.d.ts

@@ -1,29 +0,0 @@
-/**
- * @deprecated Use LanguageCodes from '@digitaldefiance/i18n-lib' instead
- */
-export declare const StringLanguages: {
-    readonly EnglishUS: "en-US";
-    readonly EnglishGB: "en-GB";
-    readonly French: "fr";
-    readonly Spanish: "es";
-    readonly German: "de";
-    readonly ChineseSimplified: "zh-CN";
-    readonly Japanese: "ja";
-    readonly Ukrainian: "uk";
-};
-/**
- * @deprecated Use LanguageCode from '@digitaldefiance/i18n-lib' instead
- */
-export type StringLanguages = (typeof StringLanguages)[keyof typeof StringLanguages];
-export type StringLanguage = StringLanguages;
-export declare const StringLanguage: {
-    readonly EnglishUS: "en-US";
-    readonly EnglishGB: "en-GB";
-    readonly French: "fr";
-    readonly Spanish: "es";
-    readonly German: "de";
-    readonly ChineseSimplified: "zh-CN";
-    readonly Japanese: "ja";
-    readonly Ukrainian: "uk";
-};
-//# sourceMappingURL=stringLanguages.d.ts.map

package/src/lib/enumerations/stringLanguages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stringLanguages.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/stringLanguages.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;CASlB,CAAC;AAEX;;GAEG;AAEH,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAIzD,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC;AAE7C,eAAO,MAAM,cAAc;;;;;;;;;CAAkB,CAAC"}

package/src/lib/enumerations/stringLanguages.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringLanguage = exports.StringLanguages = void 0;
-/**
- * String language codes - re-exported from i18n-lib for backward compatibility
- * @deprecated Use LanguageCodes from '@digitaldefiance/i18n-lib' instead
- */
-const i18n_lib_1 = require("@digitaldefiance/i18n-lib");
-/**
- * @deprecated Use LanguageCodes from '@digitaldefiance/i18n-lib' instead
- */
-exports.StringLanguages = {
-    EnglishUS: i18n_lib_1.LanguageCodes.EN_US,
-    EnglishGB: i18n_lib_1.LanguageCodes.EN_GB,
-    French: i18n_lib_1.LanguageCodes.FR,
-    Spanish: i18n_lib_1.LanguageCodes.ES,
-    German: i18n_lib_1.LanguageCodes.DE,
-    ChineseSimplified: i18n_lib_1.LanguageCodes.ZH_CN,
-    Japanese: i18n_lib_1.LanguageCodes.JA,
-    Ukrainian: i18n_lib_1.LanguageCodes.UK,
-};
-// eslint-disable-next-line no-redeclare
-exports.StringLanguage = exports.StringLanguages;
-//# sourceMappingURL=stringLanguages.js.map

package/src/lib/enumerations/stringLanguages.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stringLanguages.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/stringLanguages.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,wDAA0D;AAE1D;;GAEG;AACU,QAAA,eAAe,GAAG;IAC7B,SAAS,EAAE,wBAAa,CAAC,KAAK;IAC9B,SAAS,EAAE,wBAAa,CAAC,KAAK;IAC9B,MAAM,EAAE,wBAAa,CAAC,EAAE;IACxB,OAAO,EAAE,wBAAa,CAAC,EAAE;IACzB,MAAM,EAAE,wBAAa,CAAC,EAAE;IACxB,iBAAiB,EAAE,wBAAa,CAAC,KAAK;IACtC,QAAQ,EAAE,wBAAa,CAAC,EAAE;IAC1B,SAAS,EAAE,wBAAa,CAAC,EAAE;CACnB,CAAC;AAYX,wCAAwC;AAC3B,QAAA,cAAc,GAAG,uBAAe,CAAC"}

package/src/lib/models/index.d.ts

@@ -1,2 +0,0 @@
-export * from './user';
-//# sourceMappingURL=index.d.ts.map

package/src/lib/models/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/src/lib/models/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/models/index.ts"],"names":[],"mappings":";;;AAAA,iDAAuB"}

package/src/lib/models/user.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=user.d.ts.map

package/src/lib/models/user.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/models/user.ts"],"names":[],"mappings":""}

package/src/lib/models/user.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sequelize_1 = require("sequelize");
-const sequelize = new sequelize_1.Sequelize('sqlite::memory:');
-const User = sequelize.define('User', {
-    id: {
-        type: sequelize_1.DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    // Model attributes are defined here
-    firstName: {
-        type: sequelize_1.DataTypes.STRING,
-        allowNull: false,
-    },
-    lastName: {
-        type: sequelize_1.DataTypes.STRING,
-        // allowNull defaults to true
-    },
-}, {
-// Other model options go here
-});
-// `sequelize.define` also returns the model
-console.log(User === sequelize.models['User']); // true
-//# sourceMappingURL=user.js.map

package/src/lib/models/user.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"user.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/models/user.ts"],"names":[],"mappings":";;AAAA,yCAAiD;AACjD,MAAM,SAAS,GAAG,IAAI,qBAAS,CAAC,iBAAiB,CAAC,CAAC;AAEnD,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAC3B,MAAM,EACN;IACE,EAAE,EAAE;QACF,IAAI,EAAE,qBAAS,CAAC,MAAM;QACtB,SAAS,EAAE,KAAK;QAChB,UAAU,EAAE,IAAI;KACjB;IACD,oCAAoC;IACpC,SAAS,EAAE;QACT,IAAI,EAAE,qBAAS,CAAC,MAAM;QACtB,SAAS,EAAE,KAAK;KACjB;IACD,QAAQ,EAAE;QACR,IAAI,EAAE,qBAAS,CAAC,MAAM;QACtB,6BAA6B;KAC9B;CACF,EACD;AACE,8BAA8B;CAC/B,CACF,CAAC;AAEF,4CAA4C;AAC5C,OAAO,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO"}

package/src/lib/types.d.ts

@@ -1,11 +0,0 @@
-/**
- * Enum language translation type (stub for backward compatibility)
- * @deprecated This type is deprecated
- */
-export type EnumLanguageTranslation<_T> = Record<string, Record<string | number, string>>;
-/**
- * Create translations helper (stub for backward compatibility)
- * @deprecated This function is deprecated
- */
-export declare function createTranslations<T>(translations: T): T;
-//# sourceMappingURL=types.d.ts.map

package/src/lib/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../brightchain-lib/src/lib/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,uBAAuB,CAAC,EAAE,IAAI,MAAM,CAC9C,MAAM,EACN,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAChC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,CAExD"}

package/src/lib/types.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTranslations = createTranslations;
-/**
- * Create translations helper (stub for backward compatibility)
- * @deprecated This function is deprecated
- */
-function createTranslations(translations) {
-    return translations;
-}
-//# sourceMappingURL=types.js.map

package/src/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../brightchain-lib/src/lib/types.ts"],"names":[],"mappings":";;AAaA,gDAEC;AAND;;;GAGG;AACH,SAAgB,kBAAkB,CAAI,YAAe;IACnD,OAAO,YAAY,CAAC;AACtB,CAAC"}