metal-orm 1.1.11 → 1.1.16

package/src/decorators/transformers/transformer-metadata.ts

@@ -1,73 +1,73 @@
-import type { ColumnType } from '../../schema/column-types.js';
-
-// Transform context provides metadata about the transformation
-export interface TransformContext {
-  entityName: string;
-  propertyName: string;
-  columnType: ColumnType;
-  isUpdate: boolean;
-  originalValue?: unknown;
-  autoTransform: boolean; // Whether auto-correction is enabled
-}
-
-// Auto-transform result for validators that can fix data
-export interface AutoTransformResult<T = unknown> {
-  success: boolean;
-  correctedValue?: T;
-  message?: string;
-}
-
-// Base transformer interface
-export interface PropertyTransformer<TInput = unknown, TOutput = unknown> {
-  readonly name: string;
-  transform(value: TInput, context: TransformContext): TOutput;
-}
-
-// Validator interface (read-only, throws on failure)
-export interface PropertyValidator<T = unknown> {
-  readonly name: string;
-  validate(value: T, context: TransformContext): ValidationResult;
-}
-
-// Sanitizer interface (mutates, never throws)
-export interface PropertySanitizer<T = unknown> {
-  readonly name: string;
-  sanitize(value: T, context: TransformContext): T;
-}
-
-// Combined transformer that can validate and transform
-export interface CompositeTransformer<TInput = unknown, TOutput = unknown>
-  extends PropertyTransformer<TInput, TOutput>,
-    PropertyValidator<TInput> {}
-
-// Extended validator interface with auto-transform capability
-export interface AutoTransformableValidator<T = unknown> extends PropertyValidator<T> {
-  /**
-   * Attempts to automatically correct an invalid value.
-   * Returns undefined if auto-correction is not possible.
-   */
-  autoTransform?(value: T, context: TransformContext): AutoTransformResult<T>;
-}
-
-// Validation result
-export interface ValidationResult {
-  isValid: boolean;
-  error?: string;
-  message?: string;
-}
-
-// Transformer metadata stored during decoration phase
-export interface TransformerMetadata {
-  propertyName: string;
-  transformers: PropertyTransformer[];
-  validators: PropertyValidator[];
-  sanitizers: PropertySanitizer[];
-  executionOrder: 'before-save' | 'after-load' | 'both';
-}
-
-// Transformer configuration options
-export interface TransformerConfig {
-  auto?: boolean; // Enable auto-transform mode (default: false)
-  execute?: 'before-save' | 'after-load' | 'both'; // When to execute (default: 'both')
-  stopOnFirstError?: boolean; // Stop validation on first error (default: false)
-}
+import type { ColumnType } from '../../schema/column-types.js';
+
+// Transform context provides metadata about the transformation
+export interface TransformContext {
+  entityName: string;
+  propertyName: string;
+  columnType: ColumnType;
+  isUpdate: boolean;
+  originalValue?: unknown;
+  autoTransform: boolean; // Whether auto-correction is enabled
+}
+
+// Auto-transform result for validators that can fix data
+export interface AutoTransformResult<T = unknown> {
+  success: boolean;
+  correctedValue?: T;
+  message?: string;
+}
+
+// Base transformer interface
+export interface PropertyTransformer<TInput = unknown, TOutput = unknown> {
+  readonly name: string;
+  transform(value: TInput, context: TransformContext): TOutput;
+}
+
+// Validator interface (read-only, throws on failure)
+export interface PropertyValidator<T = unknown> {
+  readonly name: string;
+  validate(value: T, context: TransformContext): ValidationResult;
+}
+
+// Sanitizer interface (mutates, never throws)
+export interface PropertySanitizer<T = unknown> {
+  readonly name: string;
+  sanitize(value: T, context: TransformContext): T;
+}
+
+// Combined transformer that can validate and transform
+export interface CompositeTransformer<TInput = unknown, TOutput = unknown>
+  extends PropertyTransformer<TInput, TOutput>,
+    PropertyValidator<TInput> {}
+
+// Extended validator interface with auto-transform capability
+export interface AutoTransformableValidator<T = unknown> extends PropertyValidator<T> {
+  /**
+   * Attempts to automatically correct an invalid value.
+   * Returns undefined if auto-correction is not possible.
+   */
+  autoTransform?(value: T, context: TransformContext): AutoTransformResult<T>;
+}
+
+// Validation result
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+  message?: string;
+}
+
+// Transformer metadata stored during decoration phase
+export interface TransformerMetadata {
+  propertyName: string;
+  transformers: PropertyTransformer[];
+  validators: PropertyValidator[];
+  sanitizers: PropertySanitizer[];
+  executionOrder: 'before-save' | 'after-load' | 'both';
+}
+
+// Transformer configuration options
+export interface TransformerConfig {
+  auto?: boolean; // Enable auto-transform mode (default: false)
+  execute?: 'before-save' | 'after-load' | 'both'; // When to execute (default: 'both')
+  stopOnFirstError?: boolean; // Stop validation on first error (default: false)
+}

package/src/decorators/validators/built-in/br-cep-validator.ts

@@ -1,55 +1,55 @@
-import type { CountryValidator, ValidationOptions, ValidationResult, AutoCorrectionResult } from '../country-validators.js';
-
-/**
- * Brazilian CEP validator
- * Format: XXXXX-XXX (8 digits)
- */
-export class CEPValidator implements CountryValidator<string> {
-  readonly countryCode = 'BR';
-  readonly identifierType = 'cep';
-  readonly name = 'br-cep';
-  
-  validate(value: string, options: ValidationOptions = {}): ValidationResult {
-    const normalized = this.normalize(value);
-    
-    // Validate format
-    if (!/^\d{8}$/.test(normalized)) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'CEP must contain exactly 8 numeric digits' 
-      };
-    }
-    
-    return { 
-      isValid: true, 
-      normalizedValue: normalized, 
-      formattedValue: this.format(value) 
-    };
-  }
-  
-  normalize(value: string): string {
-    return value.replace(/[^0-9]/g, '');
-  }
-  
-  format(value: string): string {
-    const normalized = this.normalize(value);
-    if (normalized.length !== 8) return value;
-    return normalized.replace(/(\d{5})(\d{3})/, '$1-$2');
-  }
-  
-  autoCorrect(value: string): AutoCorrectionResult<string> {
-    const normalized = this.normalize(value);
-    
-    if (normalized.length === 8) {
-      return { success: true, correctedValue: this.format(normalized) };
-    }
-    
-    if (normalized.length < 8) {
-      const padded = normalized.padEnd(8, '0');
-      return { success: true, correctedValue: this.format(padded) };
-    }
-    
-    const truncated = normalized.slice(0, 8);
-    return { success: true, correctedValue: this.format(truncated) };
-  }
-}
+import type { CountryValidator, ValidationOptions, ValidationResult, AutoCorrectionResult } from '../country-validators.js';
+
+/**
+ * Brazilian CEP validator
+ * Format: XXXXX-XXX (8 digits)
+ */
+export class CEPValidator implements CountryValidator<string> {
+  readonly countryCode = 'BR';
+  readonly identifierType = 'cep';
+  readonly name = 'br-cep';
+  
+  validate(value: string, options: ValidationOptions = {}): ValidationResult {
+    const normalized = this.normalize(value);
+    
+    // Validate format
+    if (!/^\d{8}$/.test(normalized)) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'CEP must contain exactly 8 numeric digits' 
+      };
+    }
+    
+    return { 
+      isValid: true, 
+      normalizedValue: normalized, 
+      formattedValue: this.format(value) 
+    };
+  }
+  
+  normalize(value: string): string {
+    return value.replace(/[^0-9]/g, '');
+  }
+  
+  format(value: string): string {
+    const normalized = this.normalize(value);
+    if (normalized.length !== 8) return value;
+    return normalized.replace(/(\d{5})(\d{3})/, '$1-$2');
+  }
+  
+  autoCorrect(value: string): AutoCorrectionResult<string> {
+    const normalized = this.normalize(value);
+    
+    if (normalized.length === 8) {
+      return { success: true, correctedValue: this.format(normalized) };
+    }
+    
+    if (normalized.length < 8) {
+      const padded = normalized.padEnd(8, '0');
+      return { success: true, correctedValue: this.format(padded) };
+    }
+    
+    const truncated = normalized.slice(0, 8);
+    return { success: true, correctedValue: this.format(truncated) };
+  }
+}

package/src/decorators/validators/built-in/br-cnpj-validator.ts

@@ -1,105 +1,105 @@
-import type { CountryValidator, ValidationOptions, ValidationResult, AutoCorrectionResult } from '../country-validators.js';
-
-/**
- * Brazilian CNPJ validator
- * Format: XX.XXX.XXX/XXXX-XX (14 digits)
- * Checksum: Mod 11 algorithm
- */
-export class CNPJValidator implements CountryValidator<string> {
-  readonly countryCode = 'BR';
-  readonly identifierType = 'cnpj';
-  readonly name = 'br-cnpj';
-  
-  validate(value: string, options: ValidationOptions = {}): ValidationResult {
-    const normalized = this.normalize(value);
-    
-    // Validate format
-    if (!/^\d{14}$/.test(normalized)) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'CNPJ must contain exactly 14 numeric digits' 
-      };
-    }
-    
-    // Check for known invalid CNPJs
-    if (this.isKnownInvalid(normalized) && options.strict !== false) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'Invalid CNPJ number' 
-      };
-    }
-    
-    // Validate checksum
-    if (!this.validateChecksum(normalized)) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'Invalid CNPJ checksum' 
-      };
-    }
-    
-    return { 
-      isValid: true, 
-      normalizedValue: normalized, 
-      formattedValue: this.format(value) 
-    };
-  }
-  
-  normalize(value: string): string {
-    return value.replace(/[^0-9]/g, '');
-  }
-  
-  format(value: string): string {
-    const normalized = this.normalize(value);
-    if (normalized.length !== 14) return value;
-    return normalized.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '$1.$2.$3/$4-$5');
-  }
-  
-  autoCorrect(value: string): AutoCorrectionResult<string> {
-    const normalized = this.normalize(value);
-    
-    if (normalized.length === 14) {
-      return { success: true, correctedValue: this.format(normalized) };
-    }
-    
-    if (normalized.length < 14) {
-      const padded = normalized.padEnd(14, '0');
-      return { success: true, correctedValue: this.format(padded) };
-    }
-    
-    const truncated = normalized.slice(0, 14);
-    return { success: true, correctedValue: this.format(truncated) };
-  }
-  
-  private isKnownInvalid(cnpj: string): boolean {
-    // Check for CNPJs with all digits the same (e.g., 00.000.000/0000-00)
-    return /^(\d)\1{13}$/.test(cnpj);
-  }
-  
-  private validateChecksum(cnpj: string): boolean {
-    const digits = cnpj.split('').map(Number);
-    const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
-    const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
-    
-    // Calculate first check digit
-    let sum = 0;
-    for (let i = 0; i < 12; i++) {
-      sum += digits[i] * weights1[i];
-    }
-    let check1 = sum % 11;
-    check1 = check1 < 2 ? 0 : 11 - check1;
-    
-    if (check1 !== digits[12]) {
-      return false;
-    }
-    
-    // Calculate second check digit
-    sum = 0;
-    for (let i = 0; i < 13; i++) {
-      sum += digits[i] * weights2[i];
-    }
-    let check2 = sum % 11;
-    check2 = check2 < 2 ? 0 : 11 - check2;
-    
-    return check2 === digits[13];
-  }
-}
+import type { CountryValidator, ValidationOptions, ValidationResult, AutoCorrectionResult } from '../country-validators.js';
+
+/**
+ * Brazilian CNPJ validator
+ * Format: XX.XXX.XXX/XXXX-XX (14 digits)
+ * Checksum: Mod 11 algorithm
+ */
+export class CNPJValidator implements CountryValidator<string> {
+  readonly countryCode = 'BR';
+  readonly identifierType = 'cnpj';
+  readonly name = 'br-cnpj';
+  
+  validate(value: string, options: ValidationOptions = {}): ValidationResult {
+    const normalized = this.normalize(value);
+    
+    // Validate format
+    if (!/^\d{14}$/.test(normalized)) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'CNPJ must contain exactly 14 numeric digits' 
+      };
+    }
+    
+    // Check for known invalid CNPJs
+    if (this.isKnownInvalid(normalized) && options.strict !== false) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'Invalid CNPJ number' 
+      };
+    }
+    
+    // Validate checksum
+    if (!this.validateChecksum(normalized)) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'Invalid CNPJ checksum' 
+      };
+    }
+    
+    return { 
+      isValid: true, 
+      normalizedValue: normalized, 
+      formattedValue: this.format(value) 
+    };
+  }
+  
+  normalize(value: string): string {
+    return value.replace(/[^0-9]/g, '');
+  }
+  
+  format(value: string): string {
+    const normalized = this.normalize(value);
+    if (normalized.length !== 14) return value;
+    return normalized.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '$1.$2.$3/$4-$5');
+  }
+  
+  autoCorrect(value: string): AutoCorrectionResult<string> {
+    const normalized = this.normalize(value);
+    
+    if (normalized.length === 14) {
+      return { success: true, correctedValue: this.format(normalized) };
+    }
+    
+    if (normalized.length < 14) {
+      const padded = normalized.padEnd(14, '0');
+      return { success: true, correctedValue: this.format(padded) };
+    }
+    
+    const truncated = normalized.slice(0, 14);
+    return { success: true, correctedValue: this.format(truncated) };
+  }
+  
+  private isKnownInvalid(cnpj: string): boolean {
+    // Check for CNPJs with all digits the same (e.g., 00.000.000/0000-00)
+    return /^(\d)\1{13}$/.test(cnpj);
+  }
+  
+  private validateChecksum(cnpj: string): boolean {
+    const digits = cnpj.split('').map(Number);
+    const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    
+    // Calculate first check digit
+    let sum = 0;
+    for (let i = 0; i < 12; i++) {
+      sum += digits[i] * weights1[i];
+    }
+    let check1 = sum % 11;
+    check1 = check1 < 2 ? 0 : 11 - check1;
+    
+    if (check1 !== digits[12]) {
+      return false;
+    }
+    
+    // Calculate second check digit
+    sum = 0;
+    for (let i = 0; i < 13; i++) {
+      sum += digits[i] * weights2[i];
+    }
+    let check2 = sum % 11;
+    check2 = check2 < 2 ? 0 : 11 - check2;
+    
+    return check2 === digits[13];
+  }
+}

package/src/decorators/validators/built-in/br-cpf-validator.ts

@@ -1,103 +1,103 @@
-import type { CountryValidator, ValidationOptions, ValidationResult, AutoCorrectionResult } from '../country-validators.js';
-
-/**
- * Brazilian CPF validator
- * Format: XXX.XXX.XXX-XX (11 digits)
- * Checksum: Mod 11 algorithm
- */
-export class CPFValidator implements CountryValidator<string> {
-  readonly countryCode = 'BR';
-  readonly identifierType = 'cpf';
-  readonly name = 'br-cpf';
-  
-  validate(value: string, options: ValidationOptions = {}): ValidationResult {
-    const normalized = this.normalize(value);
-    
-    // Validate format
-    if (!/^\d{11}$/.test(normalized)) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'CPF must contain exactly 11 numeric digits' 
-      };
-    }
-    
-    // Check for known invalid CPFs
-    if (this.isKnownInvalid(normalized) && options.strict !== false) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'Invalid CPF number' 
-      };
-    }
-    
-    // Validate checksum
-    if (!this.validateChecksum(normalized)) {
-      return { 
-        isValid: false, 
-        error: options.errorMessage || 'Invalid CPF checksum' 
-      };
-    }
-    
-    return { 
-      isValid: true, 
-      normalizedValue: normalized, 
-      formattedValue: this.format(value) 
-    };
-  }
-  
-  normalize(value: string): string {
-    return value.replace(/[^0-9]/g, '');
-  }
-  
-  format(value: string): string {
-    const normalized = this.normalize(value);
-    if (normalized.length !== 11) return value;
-    return normalized.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
-  }
-  
-  autoCorrect(value: string): AutoCorrectionResult<string> {
-    const normalized = this.normalize(value);
-    
-    if (normalized.length === 11) {
-      return { success: true, correctedValue: this.format(normalized) };
-    }
-    
-    if (normalized.length < 11) {
-      const padded = normalized.padEnd(11, '0');
-      return { success: true, correctedValue: this.format(padded) };
-    }
-    
-    const truncated = normalized.slice(0, 11);
-    return { success: true, correctedValue: this.format(truncated) };
-  }
-  
-  private isKnownInvalid(cpf: string): boolean {
-    // Check for CPFs with all digits the same (e.g., 111.111.111-11)
-    return /^(\d)\1{10}$/.test(cpf);
-  }
-  
-  private validateChecksum(cpf: string): boolean {
-    const digits = cpf.split('').map(Number);
-    
-    // Calculate first check digit
-    let sum = 0;
-    for (let i = 0; i < 9; i++) {
-      sum += digits[i] * (10 - i);
-    }
-    let check1 = sum % 11;
-    check1 = check1 < 2 ? 0 : 11 - check1;
-    
-    if (check1 !== digits[9]) {
-      return false;
-    }
-    
-    // Calculate second check digit
-    sum = 0;
-    for (let i = 0; i < 10; i++) {
-      sum += digits[i] * (11 - i);
-    }
-    let check2 = sum % 11;
-    check2 = check2 < 2 ? 0 : 11 - check2;
-    
-    return check2 === digits[10];
-  }
-}
+import type { CountryValidator, ValidationOptions, ValidationResult, AutoCorrectionResult } from '../country-validators.js';
+
+/**
+ * Brazilian CPF validator
+ * Format: XXX.XXX.XXX-XX (11 digits)
+ * Checksum: Mod 11 algorithm
+ */
+export class CPFValidator implements CountryValidator<string> {
+  readonly countryCode = 'BR';
+  readonly identifierType = 'cpf';
+  readonly name = 'br-cpf';
+  
+  validate(value: string, options: ValidationOptions = {}): ValidationResult {
+    const normalized = this.normalize(value);
+    
+    // Validate format
+    if (!/^\d{11}$/.test(normalized)) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'CPF must contain exactly 11 numeric digits' 
+      };
+    }
+    
+    // Check for known invalid CPFs
+    if (this.isKnownInvalid(normalized) && options.strict !== false) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'Invalid CPF number' 
+      };
+    }
+    
+    // Validate checksum
+    if (!this.validateChecksum(normalized)) {
+      return { 
+        isValid: false, 
+        error: options.errorMessage || 'Invalid CPF checksum' 
+      };
+    }
+    
+    return { 
+      isValid: true, 
+      normalizedValue: normalized, 
+      formattedValue: this.format(value) 
+    };
+  }
+  
+  normalize(value: string): string {
+    return value.replace(/[^0-9]/g, '');
+  }
+  
+  format(value: string): string {
+    const normalized = this.normalize(value);
+    if (normalized.length !== 11) return value;
+    return normalized.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
+  }
+  
+  autoCorrect(value: string): AutoCorrectionResult<string> {
+    const normalized = this.normalize(value);
+    
+    if (normalized.length === 11) {
+      return { success: true, correctedValue: this.format(normalized) };
+    }
+    
+    if (normalized.length < 11) {
+      const padded = normalized.padEnd(11, '0');
+      return { success: true, correctedValue: this.format(padded) };
+    }
+    
+    const truncated = normalized.slice(0, 11);
+    return { success: true, correctedValue: this.format(truncated) };
+  }
+  
+  private isKnownInvalid(cpf: string): boolean {
+    // Check for CPFs with all digits the same (e.g., 111.111.111-11)
+    return /^(\d)\1{10}$/.test(cpf);
+  }
+  
+  private validateChecksum(cpf: string): boolean {
+    const digits = cpf.split('').map(Number);
+    
+    // Calculate first check digit
+    let sum = 0;
+    for (let i = 0; i < 9; i++) {
+      sum += digits[i] * (10 - i);
+    }
+    let check1 = sum % 11;
+    check1 = check1 < 2 ? 0 : 11 - check1;
+    
+    if (check1 !== digits[9]) {
+      return false;
+    }
+    
+    // Calculate second check digit
+    sum = 0;
+    for (let i = 0; i < 10; i++) {
+      sum += digits[i] * (11 - i);
+    }
+    let check2 = sum % 11;
+    check2 = check2 < 2 ? 0 : 11 - check2;
+    
+    return check2 === digits[10];
+  }
+}