metal-orm 1.1.11 → 1.1.16

package/src/decorators/validators/country-validator-registry.ts

@@ -1,64 +1,64 @@
-import type { CountryValidator, CountryValidatorFactory } from './country-validators.js';
-
-/**
- * Registry for country-specific identifier validators
- * Mirrors the INFLECTOR_FACTORIES pattern from scripts/inflection/index.mjs
- */
-const VALIDATOR_FACTORIES = new Map<string, CountryValidatorFactory>();
-
-/**
- * Registers a country validator factory
- * @param countryCode - ISO 3166-1 alpha-2 country code (e.g., 'BR', 'US')
- * @param identifierType - Identifier type (e.g., 'cpf', 'ssn')
- * @param factory - Factory function that creates a validator instance
- */
-export const registerValidator = (
-  countryCode: string,
-  identifierType: string,
-  factory: CountryValidatorFactory
-): void => {
-  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
-  if (!countryCode) throw new Error('countryCode is required');
-  if (!identifierType) throw new Error('identifierType is required');
-  if (typeof factory !== 'function') {
-    throw new Error('factory must be a function that returns a validator');
-  }
-  VALIDATOR_FACTORIES.set(key, factory);
-};
-
-/**
- * Resolves a validator for a given country and identifier type
- * @param countryCode - ISO 3166-1 alpha-2 country code
- * @param identifierType - Identifier type
- * @returns Validator instance or undefined if not found
- */
-export const resolveValidator = (
-  countryCode: string,
-  identifierType: string
-): CountryValidator | undefined => {
-  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
-  const factory = VALIDATOR_FACTORIES.get(key);
-  return factory ? factory() : undefined;
-};
-
-/**
- * Gets all registered validator keys
- * @returns Array of validator keys (e.g., ['br-cpf', 'us-ssn'])
- */
-export const getRegisteredValidators = (): string[] => {
-  return Array.from(VALIDATOR_FACTORIES.keys());
-};
-
-/**
- * Checks if a validator is registered
- * @param countryCode - ISO 3166-1 alpha-2 country code
- * @param identifierType - Identifier type
- * @returns True if validator is registered
- */
-export const hasValidator = (
-  countryCode: string,
-  identifierType: string
-): boolean => {
-  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
-  return VALIDATOR_FACTORIES.has(key);
-};
+import type { CountryValidator, CountryValidatorFactory } from './country-validators.js';
+
+/**
+ * Registry for country-specific identifier validators
+ * Mirrors the INFLECTOR_FACTORIES pattern from scripts/inflection/index.mjs
+ */
+const VALIDATOR_FACTORIES = new Map<string, CountryValidatorFactory>();
+
+/**
+ * Registers a country validator factory
+ * @param countryCode - ISO 3166-1 alpha-2 country code (e.g., 'BR', 'US')
+ * @param identifierType - Identifier type (e.g., 'cpf', 'ssn')
+ * @param factory - Factory function that creates a validator instance
+ */
+export const registerValidator = (
+  countryCode: string,
+  identifierType: string,
+  factory: CountryValidatorFactory
+): void => {
+  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
+  if (!countryCode) throw new Error('countryCode is required');
+  if (!identifierType) throw new Error('identifierType is required');
+  if (typeof factory !== 'function') {
+    throw new Error('factory must be a function that returns a validator');
+  }
+  VALIDATOR_FACTORIES.set(key, factory);
+};
+
+/**
+ * Resolves a validator for a given country and identifier type
+ * @param countryCode - ISO 3166-1 alpha-2 country code
+ * @param identifierType - Identifier type
+ * @returns Validator instance or undefined if not found
+ */
+export const resolveValidator = (
+  countryCode: string,
+  identifierType: string
+): CountryValidator | undefined => {
+  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
+  const factory = VALIDATOR_FACTORIES.get(key);
+  return factory ? factory() : undefined;
+};
+
+/**
+ * Gets all registered validator keys
+ * @returns Array of validator keys (e.g., ['br-cpf', 'us-ssn'])
+ */
+export const getRegisteredValidators = (): string[] => {
+  return Array.from(VALIDATOR_FACTORIES.keys());
+};
+
+/**
+ * Checks if a validator is registered
+ * @param countryCode - ISO 3166-1 alpha-2 country code
+ * @param identifierType - Identifier type
+ * @returns True if validator is registered
+ */
+export const hasValidator = (
+  countryCode: string,
+  identifierType: string
+): boolean => {
+  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
+  return VALIDATOR_FACTORIES.has(key);
+};

package/src/decorators/validators/country-validators-decorators.ts

@@ -1,203 +1,203 @@
-import { resolveFieldDecoratorInfo } from '../decorator-metadata.js';
-import { registerValidator } from './country-validator-registry.js';
-import { CPFValidator } from './built-in/br-cpf-validator.js';
-import { CNPJValidator } from './built-in/br-cnpj-validator.js';
-import { CEPValidator } from './built-in/br-cep-validator.js';
-
-// Register built-in validators
-registerValidator('BR', 'cpf', () => new CPFValidator());
-registerValidator('BR', 'cnpj', () => new CNPJValidator());
-registerValidator('BR', 'cep', () => new CEPValidator());
-
-const resolveCountryDecoratorInfo = (targetOrValue: unknown, contextOrProperty: unknown) => {
-  return resolveFieldDecoratorInfo(targetOrValue, contextOrProperty, 'Country validator');
-};
-
-/**
- * Decorator to validate a Brazilian CPF number
- * @param options - Validation options
- * @returns Property decorator for CPF validation
- */
-export function CPF(options?: { strict?: boolean; errorMessage?: string }) {
-  return function (targetOrValue: unknown, contextOrProperty: unknown) {
-    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
-    
-    // Find or create transformer metadata for this property
-    let existing = bag.transformers.find(t => t.propertyName === propertyName);
-    if (!existing) {
-      existing = {
-        propertyName,
-        metadata: {
-          propertyName,
-          transformers: [],
-          validators: [],
-          sanitizers: [],
-          executionOrder: 'both'
-        }
-      };
-      bag.transformers.push(existing);
-    }
-    
-    // Create validator instance
-    const validator = new CPFValidator();
-    
-    // Add validator to metadata
-    existing.metadata.validators.push({
-      name: validator.name,
-      validate: (value: string) => {
-        const result = validator.validate(value, {
-          strict: options?.strict ?? true,
-          errorMessage: options?.errorMessage
-        });
-        return {
-          isValid: result.isValid,
-          error: result.error,
-          message: result.error
-        };
-      },
-      autoTransform: (value: string) => {
-        const correction = validator.autoCorrect(value);
-        if (correction?.success) {
-          return {
-            success: true,
-            correctedValue: correction.correctedValue,
-            message: correction.message
-          };
-        }
-        return { success: false };
-      }
-    } as unknown as never);
-    
-    // Add sanitizer to normalize and format
-    existing.metadata.sanitizers.push({
-      name: 'cpf-formatter',
-      sanitize: (value: string) => validator.format(value)
-    });
-  };
-}
-
-/**
- * Decorator to validate a Brazilian CNPJ number
- * @param options - Validation options
- * @returns Property decorator for CNPJ validation
- */
-export function CNPJ(options?: { strict?: boolean; errorMessage?: string }) {
-  return function (targetOrValue: unknown, contextOrProperty: unknown) {
-    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
-    
-    // Find or create transformer metadata for this property
-    let existing = bag.transformers.find(t => t.propertyName === propertyName);
-    if (!existing) {
-      existing = {
-        propertyName,
-        metadata: {
-          propertyName,
-          transformers: [],
-          validators: [],
-          sanitizers: [],
-          executionOrder: 'both'
-        }
-      };
-      bag.transformers.push(existing);
-    }
-    
-    // Create validator instance
-    const validator = new CNPJValidator();
-    
-    // Add validator to metadata
-    existing.metadata.validators.push({
-      name: validator.name,
-      validate: (value: string) => {
-        const result = validator.validate(value, {
-          strict: options?.strict ?? true,
-          errorMessage: options?.errorMessage
-        });
-        return {
-          isValid: result.isValid,
-          error: result.error,
-          message: result.error
-        };
-      },
-      autoTransform: (value: string) => {
-        const correction = validator.autoCorrect(value);
-        if (correction?.success) {
-          return {
-            success: true,
-            correctedValue: correction.correctedValue,
-            message: correction.message
-          };
-        }
-        return { success: false };
-      }
-    } as unknown as never);
-    
-    // Add sanitizer to normalize and format
-    existing.metadata.sanitizers.push({
-      name: 'cnpj-formatter',
-      sanitize: (value: string) => validator.format(value)
-    });
-  };
-}
-
-/**
- * Decorator to validate a Brazilian CEP number
- * @param options - Validation options
- * @returns Property decorator for CEP validation
- */
-export function CEP(options?: { strict?: boolean; errorMessage?: string }) {
-  return function (targetOrValue: unknown, contextOrProperty: unknown) {
-    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
-    
-    // Find or create transformer metadata for this property
-    let existing = bag.transformers.find(t => t.propertyName === propertyName);
-    if (!existing) {
-      existing = {
-        propertyName,
-        metadata: {
-          propertyName,
-          transformers: [],
-          validators: [],
-          sanitizers: [],
-          executionOrder: 'both'
-        }
-      };
-      bag.transformers.push(existing);
-    }
-    
-    // Create validator instance
-    const validator = new CEPValidator();
-    
-    // Add validator to metadata
-    existing.metadata.validators.push({
-      name: validator.name,
-      validate: (value: string) => {
-        const result = validator.validate(value, {
-          strict: options?.strict ?? true,
-          errorMessage: options?.errorMessage
-        });
-        return {
-          isValid: result.isValid,
-          error: result.error,
-          message: result.error
-        };
-      },
-      autoTransform: (value: string) => {
-        const correction = validator.autoCorrect(value);
-        if (correction?.success) {
-          return {
-            success: true,
-            correctedValue: correction.correctedValue,
-            message: correction.message
-          };
-        }
-        return { success: false };
-      }
-    } as unknown as never);
-    
-    // Add sanitizer to normalize and format
-    existing.metadata.sanitizers.push({
-      name: 'cep-formatter',
-      sanitize: (value: string) => validator.format(value)
-    });
-  };
-}
+import { resolveFieldDecoratorInfo } from '../decorator-metadata.js';
+import { registerValidator } from './country-validator-registry.js';
+import { CPFValidator } from './built-in/br-cpf-validator.js';
+import { CNPJValidator } from './built-in/br-cnpj-validator.js';
+import { CEPValidator } from './built-in/br-cep-validator.js';
+
+// Register built-in validators
+registerValidator('BR', 'cpf', () => new CPFValidator());
+registerValidator('BR', 'cnpj', () => new CNPJValidator());
+registerValidator('BR', 'cep', () => new CEPValidator());
+
+const resolveCountryDecoratorInfo = (targetOrValue: unknown, contextOrProperty: unknown) => {
+  return resolveFieldDecoratorInfo(targetOrValue, contextOrProperty, 'Country validator');
+};
+
+/**
+ * Decorator to validate a Brazilian CPF number
+ * @param options - Validation options
+ * @returns Property decorator for CPF validation
+ */
+export function CPF(options?: { strict?: boolean; errorMessage?: string }) {
+  return function (targetOrValue: unknown, contextOrProperty: unknown) {
+    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
+    
+    // Find or create transformer metadata for this property
+    let existing = bag.transformers.find(t => t.propertyName === propertyName);
+    if (!existing) {
+      existing = {
+        propertyName,
+        metadata: {
+          propertyName,
+          transformers: [],
+          validators: [],
+          sanitizers: [],
+          executionOrder: 'both'
+        }
+      };
+      bag.transformers.push(existing);
+    }
+    
+    // Create validator instance
+    const validator = new CPFValidator();
+    
+    // Add validator to metadata
+    existing.metadata.validators.push({
+      name: validator.name,
+      validate: (value: string) => {
+        const result = validator.validate(value, {
+          strict: options?.strict ?? true,
+          errorMessage: options?.errorMessage
+        });
+        return {
+          isValid: result.isValid,
+          error: result.error,
+          message: result.error
+        };
+      },
+      autoTransform: (value: string) => {
+        const correction = validator.autoCorrect(value);
+        if (correction?.success) {
+          return {
+            success: true,
+            correctedValue: correction.correctedValue,
+            message: correction.message
+          };
+        }
+        return { success: false };
+      }
+    } as unknown as never);
+    
+    // Add sanitizer to normalize and format
+    existing.metadata.sanitizers.push({
+      name: 'cpf-formatter',
+      sanitize: (value: string) => validator.format(value)
+    });
+  };
+}
+
+/**
+ * Decorator to validate a Brazilian CNPJ number
+ * @param options - Validation options
+ * @returns Property decorator for CNPJ validation
+ */
+export function CNPJ(options?: { strict?: boolean; errorMessage?: string }) {
+  return function (targetOrValue: unknown, contextOrProperty: unknown) {
+    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
+    
+    // Find or create transformer metadata for this property
+    let existing = bag.transformers.find(t => t.propertyName === propertyName);
+    if (!existing) {
+      existing = {
+        propertyName,
+        metadata: {
+          propertyName,
+          transformers: [],
+          validators: [],
+          sanitizers: [],
+          executionOrder: 'both'
+        }
+      };
+      bag.transformers.push(existing);
+    }
+    
+    // Create validator instance
+    const validator = new CNPJValidator();
+    
+    // Add validator to metadata
+    existing.metadata.validators.push({
+      name: validator.name,
+      validate: (value: string) => {
+        const result = validator.validate(value, {
+          strict: options?.strict ?? true,
+          errorMessage: options?.errorMessage
+        });
+        return {
+          isValid: result.isValid,
+          error: result.error,
+          message: result.error
+        };
+      },
+      autoTransform: (value: string) => {
+        const correction = validator.autoCorrect(value);
+        if (correction?.success) {
+          return {
+            success: true,
+            correctedValue: correction.correctedValue,
+            message: correction.message
+          };
+        }
+        return { success: false };
+      }
+    } as unknown as never);
+    
+    // Add sanitizer to normalize and format
+    existing.metadata.sanitizers.push({
+      name: 'cnpj-formatter',
+      sanitize: (value: string) => validator.format(value)
+    });
+  };
+}
+
+/**
+ * Decorator to validate a Brazilian CEP number
+ * @param options - Validation options
+ * @returns Property decorator for CEP validation
+ */
+export function CEP(options?: { strict?: boolean; errorMessage?: string }) {
+  return function (targetOrValue: unknown, contextOrProperty: unknown) {
+    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
+    
+    // Find or create transformer metadata for this property
+    let existing = bag.transformers.find(t => t.propertyName === propertyName);
+    if (!existing) {
+      existing = {
+        propertyName,
+        metadata: {
+          propertyName,
+          transformers: [],
+          validators: [],
+          sanitizers: [],
+          executionOrder: 'both'
+        }
+      };
+      bag.transformers.push(existing);
+    }
+    
+    // Create validator instance
+    const validator = new CEPValidator();
+    
+    // Add validator to metadata
+    existing.metadata.validators.push({
+      name: validator.name,
+      validate: (value: string) => {
+        const result = validator.validate(value, {
+          strict: options?.strict ?? true,
+          errorMessage: options?.errorMessage
+        });
+        return {
+          isValid: result.isValid,
+          error: result.error,
+          message: result.error
+        };
+      },
+      autoTransform: (value: string) => {
+        const correction = validator.autoCorrect(value);
+        if (correction?.success) {
+          return {
+            success: true,
+            correctedValue: correction.correctedValue,
+            message: correction.message
+          };
+        }
+        return { success: false };
+      }
+    } as unknown as never);
+    
+    // Add sanitizer to normalize and format
+    existing.metadata.sanitizers.push({
+      name: 'cep-formatter',
+      sanitize: (value: string) => validator.format(value)
+    });
+  };
+}