metal-orm 1.0.93 → 1.0.95

package/dist/index.js

@@ -6142,7 +6142,8 @@ var ensureEntityMetadata = (target) => {
       target,
       tableName: target.name || "unknown",
       columns: {},
-      relations: {}
+      relations: {},
+      transformers: {}
     };
     metadataMap.set(target, meta);
   }
@@ -6162,6 +6163,10 @@ var addRelationMetadata = (target, propertyKey, relation) => {
   const meta = ensureEntityMetadata(target);
   meta.relations[propertyKey] = relation;
 };
+var addTransformerMetadata = (target, propertyKey, transformer) => {
+  const meta = ensureEntityMetadata(target);
+  meta.transformers[propertyKey] = transformer;
+};
 var setEntityTableName = (target, tableName, hooks) => {
   const meta = ensureEntityMetadata(target);
   if (tableName && tableName.length > 0) {
@@ -7522,6 +7527,28 @@ var isTableDef = (value) => {
   return true;
 };
 
+// src/decorators/decorator-metadata.ts
+var METADATA_KEY = "metal-orm:decorators";
+var getOrCreateMetadataBag = (context) => {
+  const metadata = context.metadata || (context.metadata = {});
+  let bag = metadata[METADATA_KEY];
+  if (!bag) {
+    bag = { columns: [], relations: [], transformers: [] };
+    metadata[METADATA_KEY] = bag;
+  }
+  return bag;
+};
+var readMetadataBag = (context) => {
+  return context.metadata?.[METADATA_KEY];
+};
+var readMetadataBagFromConstructor = (ctor) => {
+  const metadataSymbol = Symbol.metadata;
+  if (!metadataSymbol) return void 0;
+  const metadata = Reflect.get(ctor, metadataSymbol);
+  return metadata?.[METADATA_KEY];
+};
+var getDecoratorMetadata = (ctor) => readMetadataBagFromConstructor(ctor);
+
 // src/decorators/bootstrap.ts
 var unwrapTarget = (target) => {
   if (typeof target === "function" && target.prototype === void 0) {
@@ -7618,6 +7645,12 @@ var bootstrapEntities = () => {
   const metas = getAllEntityMetadata();
   const tableMap = /* @__PURE__ */ new Map();
   for (const meta of metas) {
+    const decoratorMetadata = getDecoratorMetadata(meta.target);
+    if (decoratorMetadata?.transformers) {
+      for (const { propertyName, metadata } of decoratorMetadata.transformers) {
+        addTransformerMetadata(meta.target, propertyName, metadata);
+      }
+    }
     const table = buildTableDef(meta);
     tableMap.set(meta.target, table);
   }
@@ -12260,6 +12293,31 @@ var Orm = class {
   }
 };
 
+// src/orm/column-introspection.ts
+var getColumnDefFromTarget = (target, column) => {
+  if (typeof target === "function") {
+    const meta = getEntityMetadata(target);
+    if (!meta?.columns) return void 0;
+    return meta.columns[column];
+  }
+  const table = target;
+  return table.columns[column];
+};
+var getColumnType = (target, column) => {
+  const col2 = getColumnDefFromTarget(target, column);
+  if (!col2?.type) return void 0;
+  return normalizeColumnType(col2.type);
+};
+var getDateKind = (target, column) => {
+  const type = getColumnType(target, column);
+  if (!type) return void 0;
+  if (type === "date") return "date";
+  if (type === "datetime" || type === "timestamp" || type === "timestamptz") {
+    return "date-time";
+  }
+  return void 0;
+};
+
 // src/orm/jsonify.ts
 var jsonify = (value) => {
   const record = value;
@@ -12271,28 +12329,6 @@ var jsonify = (value) => {
   return result;
 };
 
-// src/decorators/decorator-metadata.ts
-var METADATA_KEY = "metal-orm:decorators";
-var getOrCreateMetadataBag = (context) => {
-  const metadata = context.metadata || (context.metadata = {});
-  let bag = metadata[METADATA_KEY];
-  if (!bag) {
-    bag = { columns: [], relations: [] };
-    metadata[METADATA_KEY] = bag;
-  }
-  return bag;
-};
-var readMetadataBag = (context) => {
-  return context.metadata?.[METADATA_KEY];
-};
-var readMetadataBagFromConstructor = (ctor) => {
-  const metadataSymbol = Symbol.metadata;
-  if (!metadataSymbol) return void 0;
-  const metadata = Reflect.get(ctor, metadataSymbol);
-  return metadata?.[METADATA_KEY];
-};
-var getDecoratorMetadata = (ctor) => readMetadataBagFromConstructor(ctor);
-
 // src/decorators/entity.ts
 var toSnakeCase2 = (value) => {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_]+/gi, "_").replace(/__+/g, "_").replace(/^_|_$/g, "").toLowerCase();
@@ -12465,6 +12501,668 @@ function BelongsToMany(options) {
   }));
 }
 
+// src/decorators/transformers/built-in/string-transformers.ts
+var TrimTransformer = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "trim";
+  sanitize(value) {
+    if (typeof value !== "string") return value;
+    if (this.options.trimAll) {
+      return value.trim();
+    }
+    let result = value;
+    if (this.options.trimStart) {
+      result = result.trimStart();
+    }
+    if (this.options.trimEnd) {
+      result = result.trimEnd();
+    }
+    if (!this.options.trimStart && !this.options.trimEnd && !this.options.trimAll) {
+      result = result.trim();
+    }
+    return result;
+  }
+};
+var CaseTransformer = class {
+  constructor(caseType) {
+    this.caseType = caseType;
+    this.name = `case-${caseType}`;
+  }
+  name;
+  sanitize(value) {
+    if (typeof value !== "string") return value;
+    switch (this.caseType) {
+      case "lower":
+        return value.toLowerCase();
+      case "upper":
+        return value.toUpperCase();
+      case "capitalize":
+        return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+      case "title":
+        return value.split(" ").map(
+          (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+        ).join(" ");
+      default:
+        return value;
+    }
+  }
+};
+var AlphanumericValidator = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "alphanumeric";
+  validate(value) {
+    if (typeof value !== "string") {
+      return { isValid: false, error: "Value must be a string" };
+    }
+    const pattern = new RegExp(
+      `^[a-zA-Z0-9${this.options.allowSpaces ? " " : ""}${this.options.allowUnderscores ? "_" : ""}${this.options.allowHyphens ? "-" : ""}]*$`
+    );
+    return pattern.test(value) ? { isValid: true } : { isValid: false, error: "Value must contain only alphanumeric characters" };
+  }
+  autoTransform(value) {
+    if (typeof value !== "string") {
+      return { success: false };
+    }
+    let result = value;
+    result = result.replace(/[^a-zA-Z0-9]/g, (char2) => {
+      if (char2 === " " && this.options.allowSpaces) return " ";
+      if (char2 === "_" && this.options.allowUnderscores) return "_";
+      if (char2 === "-" && this.options.allowHyphens) return "-";
+      return "";
+    });
+    return {
+      success: true,
+      correctedValue: result,
+      message: "Removed non-alphanumeric characters"
+    };
+  }
+};
+var EmailValidator = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "email";
+  validate(value) {
+    if (typeof value !== "string") {
+      return { isValid: false, error: "Value must be a string" };
+    }
+    const emailPattern = this.options.allowPlus ? /^[^\s@]+@[^\s@]+\.[^\s@]+$/ : /^[^\s@+]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailPattern.test(value)) {
+      return { isValid: false, error: "Value must be a valid email address" };
+    }
+    if (this.options.requireTLD) {
+      const parts = value.split(".");
+      if (parts.length < 3 || parts[parts.length - 1].length < 2) {
+        return { isValid: false, error: "Email must have a valid top-level domain" };
+      }
+    }
+    return { isValid: true };
+  }
+  autoTransform(value) {
+    if (typeof value !== "string") {
+      return { success: false };
+    }
+    let result = value.trim().toLowerCase();
+    if (!this.options.allowPlus) {
+      result = result.replace(/\+.*@/, "@");
+    }
+    return {
+      success: true,
+      correctedValue: result,
+      message: "Trimmed and lowercased email"
+    };
+  }
+};
+var LengthValidator = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "length";
+  validate(value) {
+    if (typeof value !== "string") {
+      return { isValid: false, error: "Value must be a string" };
+    }
+    if (this.options.exact !== void 0 && value.length !== this.options.exact) {
+      return { isValid: false, error: `Value must be exactly ${this.options.exact} characters long` };
+    }
+    if (this.options.min !== void 0 && value.length < this.options.min) {
+      return { isValid: false, error: `Value must be at least ${this.options.min} characters long` };
+    }
+    if (this.options.max !== void 0 && value.length > this.options.max) {
+      return { isValid: false, error: `Value must be at most ${this.options.max} characters long` };
+    }
+    return { isValid: true };
+  }
+  autoTransform(value) {
+    if (typeof value !== "string") {
+      return { success: false };
+    }
+    let result = value;
+    if (this.options.max !== void 0 && result.length > this.options.max) {
+      result = result.slice(0, this.options.max);
+    }
+    if (this.options.min !== void 0 && result.length < this.options.min) {
+      result = result.padEnd(this.options.min);
+    }
+    return {
+      success: true,
+      correctedValue: result,
+      message: "Adjusted string length"
+    };
+  }
+};
+var PatternValidator = class {
+  constructor(options = { pattern: /.*/ }) {
+    this.options = options;
+  }
+  name = "pattern";
+  validate(value) {
+    if (typeof value !== "string") {
+      return { isValid: false, error: "Value must be a string" };
+    }
+    const pattern = new RegExp(this.options.pattern.source, this.options.flags);
+    if (!pattern.test(value)) {
+      return { isValid: false, error: this.options.errorMessage || "Value does not match required pattern" };
+    }
+    return { isValid: true };
+  }
+  autoTransform(value) {
+    if (typeof value !== "string" || !this.options.replacement) {
+      return { success: false };
+    }
+    const pattern = new RegExp(this.options.pattern.source, this.options.flags);
+    const result = value.replace(pattern, this.options.replacement);
+    return {
+      success: true,
+      correctedValue: result,
+      message: "Replaced pattern matches"
+    };
+  }
+};
+
+// src/decorators/transformers/transformer-decorators.ts
+var normalizePropertyName3 = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+var registerTransformerMetadata = (context, metadata) => {
+  const propertyName = normalizePropertyName3(context.name);
+  const bag = getOrCreateMetadataBag(context);
+  let existing = bag.transformers.find((t) => t.propertyName === propertyName);
+  if (!existing) {
+    existing = {
+      propertyName,
+      metadata: {
+        propertyName,
+        transformers: [],
+        validators: [],
+        sanitizers: [],
+        executionOrder: "both"
+      }
+    };
+    bag.transformers.push(existing);
+  }
+  if (metadata.transformers) {
+    existing.metadata.transformers.push(...metadata.transformers);
+  }
+  if (metadata.validators) {
+    existing.metadata.validators.push(...metadata.validators);
+  }
+  if (metadata.sanitizers) {
+    existing.metadata.sanitizers.push(...metadata.sanitizers);
+  }
+  if (metadata.executionOrder) {
+    existing.metadata.executionOrder = metadata.executionOrder;
+  }
+};
+function Trim(options) {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      sanitizers: [new TrimTransformer(options)]
+    });
+  };
+}
+function Lower() {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      sanitizers: [new CaseTransformer("lower")]
+    });
+  };
+}
+function Upper() {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      sanitizers: [new CaseTransformer("upper")]
+    });
+  };
+}
+function Capitalize() {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      sanitizers: [new CaseTransformer("capitalize")]
+    });
+  };
+}
+function Title() {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      sanitizers: [new CaseTransformer("title")]
+    });
+  };
+}
+function Alphanumeric(options) {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      validators: [new AlphanumericValidator(options)]
+    });
+  };
+}
+function Email(options) {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      validators: [new EmailValidator(options)]
+    });
+  };
+}
+function Length(options) {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      validators: [new LengthValidator(options)]
+    });
+  };
+}
+function Pattern(options) {
+  return function(_value, context) {
+    registerTransformerMetadata(context, {
+      validators: [new PatternValidator(options)]
+    });
+  };
+}
+
+// src/decorators/validators/country-validator-registry.ts
+var VALIDATOR_FACTORIES = /* @__PURE__ */ new Map();
+var registerValidator = (countryCode, identifierType, factory) => {
+  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);
+};
+var resolveValidator = (countryCode, identifierType) => {
+  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
+  const factory = VALIDATOR_FACTORIES.get(key);
+  return factory ? factory() : void 0;
+};
+var getRegisteredValidators = () => {
+  return Array.from(VALIDATOR_FACTORIES.keys());
+};
+var hasValidator = (countryCode, identifierType) => {
+  const key = `${countryCode.toLowerCase()}-${identifierType.toLowerCase()}`;
+  return VALIDATOR_FACTORIES.has(key);
+};
+
+// src/decorators/validators/built-in/br-cpf-validator.ts
+var CPFValidator = class {
+  countryCode = "BR";
+  identifierType = "cpf";
+  name = "br-cpf";
+  validate(value, options = {}) {
+    const normalized = this.normalize(value);
+    if (!/^\d{11}$/.test(normalized)) {
+      return {
+        isValid: false,
+        error: options.errorMessage || "CPF must contain exactly 11 numeric digits"
+      };
+    }
+    if (this.isKnownInvalid(normalized) && options.strict !== false) {
+      return {
+        isValid: false,
+        error: options.errorMessage || "Invalid CPF number"
+      };
+    }
+    if (!this.validateChecksum(normalized)) {
+      return {
+        isValid: false,
+        error: options.errorMessage || "Invalid CPF checksum"
+      };
+    }
+    return {
+      isValid: true,
+      normalizedValue: normalized,
+      formattedValue: this.format(value)
+    };
+  }
+  normalize(value) {
+    return value.replace(/[^0-9]/g, "");
+  }
+  format(value) {
+    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) {
+    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) };
+  }
+  isKnownInvalid(cpf) {
+    return /^(\d)\1{10}$/.test(cpf);
+  }
+  validateChecksum(cpf) {
+    const digits = cpf.split("").map(Number);
+    let sum2 = 0;
+    for (let i = 0; i < 9; i++) {
+      sum2 += digits[i] * (10 - i);
+    }
+    let check1 = sum2 % 11;
+    check1 = check1 < 2 ? 0 : 11 - check1;
+    if (check1 !== digits[9]) {
+      return false;
+    }
+    sum2 = 0;
+    for (let i = 0; i < 10; i++) {
+      sum2 += digits[i] * (11 - i);
+    }
+    let check2 = sum2 % 11;
+    check2 = check2 < 2 ? 0 : 11 - check2;
+    return check2 === digits[10];
+  }
+};
+
+// src/decorators/validators/built-in/br-cnpj-validator.ts
+var CNPJValidator = class {
+  countryCode = "BR";
+  identifierType = "cnpj";
+  name = "br-cnpj";
+  validate(value, options = {}) {
+    const normalized = this.normalize(value);
+    if (!/^\d{14}$/.test(normalized)) {
+      return {
+        isValid: false,
+        error: options.errorMessage || "CNPJ must contain exactly 14 numeric digits"
+      };
+    }
+    if (this.isKnownInvalid(normalized) && options.strict !== false) {
+      return {
+        isValid: false,
+        error: options.errorMessage || "Invalid CNPJ number"
+      };
+    }
+    if (!this.validateChecksum(normalized)) {
+      return {
+        isValid: false,
+        error: options.errorMessage || "Invalid CNPJ checksum"
+      };
+    }
+    return {
+      isValid: true,
+      normalizedValue: normalized,
+      formattedValue: this.format(value)
+    };
+  }
+  normalize(value) {
+    return value.replace(/[^0-9]/g, "");
+  }
+  format(value) {
+    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) {
+    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) };
+  }
+  isKnownInvalid(cnpj) {
+    return /^(\d)\1{13}$/.test(cnpj);
+  }
+  validateChecksum(cnpj) {
+    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];
+    let sum2 = 0;
+    for (let i = 0; i < 12; i++) {
+      sum2 += digits[i] * weights1[i];
+    }
+    let check1 = sum2 % 11;
+    check1 = check1 < 2 ? 0 : 11 - check1;
+    if (check1 !== digits[12]) {
+      return false;
+    }
+    sum2 = 0;
+    for (let i = 0; i < 13; i++) {
+      sum2 += digits[i] * weights2[i];
+    }
+    let check2 = sum2 % 11;
+    check2 = check2 < 2 ? 0 : 11 - check2;
+    return check2 === digits[13];
+  }
+};
+
+// src/decorators/validators/built-in/br-cep-validator.ts
+var CEPValidator = class {
+  countryCode = "BR";
+  identifierType = "cep";
+  name = "br-cep";
+  validate(value, options = {}) {
+    const normalized = this.normalize(value);
+    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) {
+    return value.replace(/[^0-9]/g, "");
+  }
+  format(value) {
+    const normalized = this.normalize(value);
+    if (normalized.length !== 8) return value;
+    return normalized.replace(/(\d{5})(\d{3})/, "$1-$2");
+  }
+  autoCorrect(value) {
+    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) };
+  }
+};
+
+// src/decorators/validators/country-validators-decorators.ts
+registerValidator("BR", "cpf", () => new CPFValidator());
+registerValidator("BR", "cnpj", () => new CNPJValidator());
+registerValidator("BR", "cep", () => new CEPValidator());
+var normalizePropertyName4 = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+function CPF(options) {
+  return function(_value, context) {
+    const propertyName = normalizePropertyName4(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    let existing = bag.transformers.find((t) => t.propertyName === propertyName);
+    if (!existing) {
+      existing = {
+        propertyName,
+        metadata: {
+          propertyName,
+          transformers: [],
+          validators: [],
+          sanitizers: [],
+          executionOrder: "both"
+        }
+      };
+      bag.transformers.push(existing);
+    }
+    const validator = new CPFValidator();
+    existing.metadata.validators.push({
+      name: validator.name,
+      validate: (value) => {
+        const result = validator.validate(value, {
+          strict: options?.strict ?? true,
+          errorMessage: options?.errorMessage
+        });
+        return {
+          isValid: result.isValid,
+          error: result.error,
+          message: result.error
+        };
+      },
+      autoTransform: (value) => {
+        const correction = validator.autoCorrect(value);
+        if (correction?.success) {
+          return {
+            success: true,
+            correctedValue: correction.correctedValue,
+            message: correction.message
+          };
+        }
+        return { success: false };
+      }
+    });
+    existing.metadata.sanitizers.push({
+      name: "cpf-formatter",
+      sanitize: (value) => validator.format(value)
+    });
+  };
+}
+function CNPJ(options) {
+  return function(_value, context) {
+    const propertyName = normalizePropertyName4(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    let existing = bag.transformers.find((t) => t.propertyName === propertyName);
+    if (!existing) {
+      existing = {
+        propertyName,
+        metadata: {
+          propertyName,
+          transformers: [],
+          validators: [],
+          sanitizers: [],
+          executionOrder: "both"
+        }
+      };
+      bag.transformers.push(existing);
+    }
+    const validator = new CNPJValidator();
+    existing.metadata.validators.push({
+      name: validator.name,
+      validate: (value) => {
+        const result = validator.validate(value, {
+          strict: options?.strict ?? true,
+          errorMessage: options?.errorMessage
+        });
+        return {
+          isValid: result.isValid,
+          error: result.error,
+          message: result.error
+        };
+      },
+      autoTransform: (value) => {
+        const correction = validator.autoCorrect(value);
+        if (correction?.success) {
+          return {
+            success: true,
+            correctedValue: correction.correctedValue,
+            message: correction.message
+          };
+        }
+        return { success: false };
+      }
+    });
+    existing.metadata.sanitizers.push({
+      name: "cnpj-formatter",
+      sanitize: (value) => validator.format(value)
+    });
+  };
+}
+function CEP(options) {
+  return function(_value, context) {
+    const propertyName = normalizePropertyName4(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    let existing = bag.transformers.find((t) => t.propertyName === propertyName);
+    if (!existing) {
+      existing = {
+        propertyName,
+        metadata: {
+          propertyName,
+          transformers: [],
+          validators: [],
+          sanitizers: [],
+          executionOrder: "both"
+        }
+      };
+      bag.transformers.push(existing);
+    }
+    const validator = new CEPValidator();
+    existing.metadata.validators.push({
+      name: validator.name,
+      validate: (value) => {
+        const result = validator.validate(value, {
+          strict: options?.strict ?? true,
+          errorMessage: options?.errorMessage
+        });
+        return {
+          isValid: result.isValid,
+          error: result.error,
+          message: result.error
+        };
+      },
+      autoTransform: (value) => {
+        const correction = validator.autoCorrect(value);
+        if (correction?.success) {
+          return {
+            success: true,
+            correctedValue: correction.correctedValue,
+            message: correction.message
+          };
+        }
+        return { success: false };
+      }
+    });
+    existing.metadata.sanitizers.push({
+      name: "cep-formatter",
+      sanitize: (value) => validator.format(value)
+    });
+  };
+}
+
 // src/core/execution/db-executor.ts
 function rowsToQueryResult(rows) {
   if (rows.length === 0) {
@@ -14279,11 +14977,16 @@ function pagedResponseToOpenApiSchema(itemSchema) {
   };
 }
 export {
+  Alphanumeric,
   AsyncLocalStorage,
   BelongsTo,
   BelongsToMany,
   BigIntTypeStrategy,
   BooleanTypeStrategy,
+  CEP,
+  CNPJ,
+  CPF,
+  Capitalize,
   Column,
   ConstructorMaterializationStrategy,
   DateTimeTypeStrategy,
@@ -14295,6 +14998,7 @@ export {
   DefaultTypeStrategy,
   DeleteQueryBuilder,
   DomainEventBus,
+  Email,
   Entity,
   EntityStatus,
   HasMany,
@@ -14302,9 +15006,12 @@ export {
   InsertQueryBuilder,
   IntegerTypeStrategy,
   InterceptorPipeline,
+  Length,
+  Lower,
   MySqlDialect,
   Orm,
   OrmSession,
+  Pattern,
   Pool,
   PostgresDialect,
   PrimaryKey,
@@ -14315,9 +15022,12 @@ export {
   SqlServerDialect,
   SqliteDialect,
   StringTypeStrategy,
+  Title,
+  Trim,
   TypeMappingService,
   TypeScriptGenerator,
   UpdateQueryBuilder,
+  Upper,
   UuidTypeStrategy,
   abs,
   acos,
@@ -14432,9 +15142,12 @@ export {
   generateSchemaSqlFor,
   getColumn,
   getColumnMap,
+  getColumnType,
+  getDateKind,
   getDecoratorMetadata,
   getDeterministicComponentName,
   getOpenApiVersionForDialect,
+  getRegisteredValidators,
   getSchemaIntrospector,
   getTableDefFromEntity,
   greatest,
@@ -14445,6 +15158,7 @@ export {
   hasNextPage as hasNextPageMeta,
   hasOne,
   hasPrevPage as hasPrevPageMeta,
+  hasValidator,
   hour,
   hydrateRows,
   ifNull,
@@ -14538,6 +15252,7 @@ export {
   registerExpressionDispatcher,
   registerOperandDispatcher,
   registerSchemaIntrospector,
+  registerValidator,
   relationFilterToOpenApiSchema,
   relationLoaderCache,
   renderColumnDefinition,
@@ -14545,6 +15260,7 @@ export {
   repeat,
   replace,
   replaceWithRefs,
+  resolveValidator,
   responseToRef,
   reverse,
   right,