@fiado/type-kit 3.419.0 → 3.421.0

package/_test_/unit/messagesConnector/IsTemplatePlaceholders.test.ts

@@ -0,0 +1,43 @@
+import { IsTemplatePlaceholders } from '../../../src/messagesConnector/validators/IsTemplatePlaceholders';
+
+const validador = new IsTemplatePlaceholders();
+const acepta = (texto: unknown): boolean => validador.validate(texto);
+
+describe('IsTemplatePlaceholders', () => {
+    describe('acepta las dos formas que el renderizador sustituye', () => {
+        it.each([
+            ['sin placeholders', 'Hola, tu credito esta al corriente'],
+            ['forma simple', 'Hola {cliente_nombre}, tu cuota es {monto}'],
+            ['forma doble', 'Hola {{cliente_nombre}}, tu cuota es {{monto}}'],
+            ['las dos mezcladas', 'Hola {{cliente_nombre}}, vence el {fecha_venc}'],
+            ['nombre con digitos y guion bajo', 'Codigo {var1} y {otra_var2}'],
+            ['cadena vacia', ''],
+        ])('%s', (_caso, texto) => {
+            expect(acepta(texto)).toBe(true);
+        });
+    });
+
+    describe('rechaza lo que el renderizador no podria sustituir', () => {
+        it.each([
+            ['placeholder vacio simple', '{}'],
+            ['placeholder vacio doble', '{{}}'],
+            ['nombre con espacio', '{var name}'],
+            ['nombre con guion', '{var-1}'],
+            ['nombre que arranca con digito', '{1var}'],
+            ['apertura sin cierre', 'abc {def'],
+            ['cierre sin apertura', 'abc } def'],
+            ['llave suelta antes de uno valido', '{ {anidado}'],
+            ['doble sin cerrar del todo', '{{a}'],
+            ['no es string', 42],
+            ['nulo', null],
+        ])('%s', (_caso, texto) => {
+            expect(acepta(texto)).toBe(false);
+        });
+    });
+
+    it('el mensaje nombra las dos formas, para que el front sepa cual usar', () => {
+        const mensaje = validador.defaultMessage({ property: 'template' } as never);
+        expect(mensaje).toContain('{nombre}');
+        expect(mensaje).toContain('{{nombre}}');
+    });
+});

package/_test_/unit/messagesConnector/MdmNotifyQueueMessageRequest.test.ts

@@ -0,0 +1,136 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate, ValidationError } from 'class-validator';
+import { MdmNotifyItem } from '../../../src/messagesConnector/dtos/MdmNotifyItem';
+import { MdmNotifyQueueMessageRequest } from '../../../src/messagesConnector/dtos/MdmNotifyQueueMessageRequest';
+import * as MessagesConnectorBarrel from '../../../src/messagesConnector/index';
+import { DeviceNotifyIntensityEnum } from '../../../src/mdm/enums/DeviceNotifyIntensityEnum';
+import { MdmNoticeTypeEnum } from '../../../src/mdm/enums/MdmNoticeTypeEnum';
+import { MdmProviderEnum } from '../../../src/mdm/enums/MdmProviderEnum';
+import { MDM_NOTIFY_MAX_BATCH } from '../../../src/messagesConnector/constants/MdmNotifyBatchLimits';
+
+/** ULID real del motor: así genera los creditId `loan-credit-business`. */
+const CREDIT_ID = '01M0B5D7FQA3T06K4REEVPRM33';
+
+const validItem = {
+    imei: '351756051523999',
+    creditId: CREDIT_ID,
+    provider: MdmProviderEnum.TRUSTONIC,
+    noticeType: MdmNoticeTypeEnum.OVERDUE_1_DAY,
+    intensity: DeviceNotifyIntensityEnum.BANNER,
+};
+
+/** Lote de `size` equipos con imei distinto: el lote real nunca repite imei. */
+const batchOf = (size: number): Record<string, unknown>[] =>
+    Array.from({ length: size }, (_unused, index) => ({ ...validItem, imei: `35175605152${String(index).padStart(4, '0')}` }));
+
+const validMessage = {
+    items: [validItem],
+    operationReference: 'mdm-notify-2026-09-08-0001',
+};
+
+/** True si el error de `property` trae ese constraint puntual (no solo "algo falló"). */
+const hasConstraint = (errors: ValidationError[], property: string, constraint: string): boolean =>
+    errors.some((e) => e.property === property && Boolean(e.constraints?.[constraint]));
+
+const validateMessage = async (payload: Record<string, unknown>): Promise<ValidationError[]> =>
+    validate(plainToInstance(MdmNotifyQueueMessageRequest, { ...validMessage, ...payload }));
+
+describe('MdmNotifyQueueMessageRequest', () => {
+    it('valida el mensaje mínimo de la cola', async () => {
+        expect(await validateMessage({})).toEqual([]);
+    });
+
+    it('valida sin tenantId: messages-business asume FIADO', async () => {
+        const dto = plainToInstance(MdmNotifyQueueMessageRequest, validMessage);
+        expect(await validate(dto)).toEqual([]);
+        expect(dto.tenantId).toBeUndefined();
+    });
+
+    it('valida con tenantId explícito', async () => {
+        expect(await validateMessage({ tenantId: 'SUREKEEP' })).toEqual([]);
+    });
+
+    it('falla si tenantId viene vacío: ausente cae a FIADO, pero "" no es un tenant', async () => {
+        expect(hasConstraint(await validateMessage({ tenantId: '' }), 'tenantId', 'isNotEmpty')).toBe(true);
+    });
+
+    it('falla si el lote viene vacío', async () => {
+        expect(hasConstraint(await validateMessage({ items: [] }), 'items', 'arrayNotEmpty')).toBe(true);
+    });
+
+    it('falla si items no es un arreglo', async () => {
+        expect(hasConstraint(await validateMessage({ items: 'nada' }), 'items', 'isArray')).toBe(true);
+    });
+
+    it('falla si items no viaja', async () => {
+        const { items: _omitted, ...rest } = validMessage;
+        const errors = await validate(plainToInstance(MdmNotifyQueueMessageRequest, rest));
+        expect(hasConstraint(errors, 'items', 'arrayNotEmpty')).toBe(true);
+    });
+
+    it('falla si dos ítems repiten el mismo imei: el equipo recibiría el aviso dos veces y el acuse colapsa en uno', async () => {
+        expect(hasConstraint(await validateMessage({ items: [validItem, validItem] }), 'items', 'arrayUnique')).toBe(true);
+    });
+
+    it('acepta el lote completo hasta el tope', async () => {
+        expect(await validateMessage({ items: batchOf(MDM_NOTIFY_MAX_BATCH) })).toEqual([]);
+    });
+
+    it('falla si el lote excede el tope de equipos', async () => {
+        const errors = await validateMessage({ items: batchOf(MDM_NOTIFY_MAX_BATCH + 1) });
+        expect(hasConstraint(errors, 'items', 'arrayMaxSize')).toBe(true);
+    });
+
+    it('el tope del lote es el mismo que el del endpoint HTTP que reemplaza', () => {
+        expect(MDM_NOTIFY_MAX_BATCH).toBe(500);
+    });
+
+    it('falla si operationReference no viaja', async () => {
+        const { operationReference: _omitted, ...rest } = validMessage;
+        const errors = await validate(plainToInstance(MdmNotifyQueueMessageRequest, rest));
+        expect(hasConstraint(errors, 'operationReference', 'isNotEmpty')).toBe(true);
+    });
+
+    it('falla si operationReference viene vacío', async () => {
+        expect(hasConstraint(await validateMessage({ operationReference: '' }), 'operationReference', 'isNotEmpty')).toBe(true);
+    });
+
+    it('falla si operationReference excede el largo máximo', async () => {
+        const errors = await validateMessage({ operationReference: 'x'.repeat(65) });
+        expect(hasConstraint(errors, 'operationReference', 'maxLength')).toBe(true);
+    });
+
+    it('acepta operationReference justo en el largo máximo', async () => {
+        expect(await validateMessage({ operationReference: 'x'.repeat(64) })).toEqual([]);
+    });
+
+    it('falla si un ítem trae un provider fuera del enum', async () => {
+        const errors = await validateMessage({ items: [{ ...validItem, provider: 'AIRDROID' }] });
+        const children = errors.find((e) => e.property === 'items')?.children ?? [];
+        expect(hasConstraint(children[0]?.children ?? [], 'provider', 'isEnum')).toBe(true);
+    });
+
+    it('falla si un ítem trae un noticeType fuera del catálogo', async () => {
+        const errors = await validateMessage({ items: [{ ...validItem, noticeType: 'OVERDUE_99_DAYS' }] });
+        const children = errors.find((e) => e.property === 'items')?.children ?? [];
+        expect(hasConstraint(children[0]?.children ?? [], 'noticeType', 'isEnum')).toBe(true);
+    });
+
+    it('falla si un ítem trae un creditId que no es ULID', async () => {
+        const errors = await validateMessage({ items: [{ ...validItem, creditId: 'no-es-ulid' }] });
+        const children = errors.find((e) => e.property === 'items')?.children ?? [];
+        expect(hasConstraint(children[0]?.children ?? [], 'creditId', 'matches')).toBe(true);
+    });
+
+    it('materializa los ítems como MdmNotifyItem', () => {
+        const dto = plainToInstance(MdmNotifyQueueMessageRequest, validMessage);
+        expect(dto.items[0]).toBeInstanceOf(MdmNotifyItem);
+    });
+});
+
+describe('barrel de messagesConnector', () => {
+    it('exporta el mensaje de cola de avisos MDM', () => {
+        expect(MessagesConnectorBarrel.MdmNotifyQueueMessageRequest).toBe(MdmNotifyQueueMessageRequest);
+    });
+});

package/bin/messagesConnector/dtos/MdmNotifyQueueMessageRequest.d.ts

@@ -0,0 +1,16 @@
+import { MdmNotifyItem } from './MdmNotifyItem';
+/**
+ * Mensaje que viaja por la cola de messages-business para avisar en lote a los equipos.
+ * Reemplaza al `POST /private/messages/mdm-notify`, que se retira.
+ */
+export declare class MdmNotifyQueueMessageRequest {
+    /**
+     * Equipos del lote. El tope es el mismo que el del lote de `loan-credit-business`.
+     * El imei repetido duplica el aviso en el equipo y colapsa los dos acuses en uno.
+     */
+    items: MdmNotifyItem[];
+    /** Tenant emisor del aviso. Si se omite, messages-business asume FIADO. */
+    tenantId?: string;
+    /** Referencia con la que el productor correlaciona este lote. Es la que viaja al proveedor. */
+    operationReference: string;
+}

package/bin/messagesConnector/dtos/MdmNotifyQueueMessageRequest.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdmNotifyQueueMessageRequest = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const MdmNotifyItem_1 = require("./MdmNotifyItem");
+const MdmNotifyBatchLimits_1 = require("../constants/MdmNotifyBatchLimits");
+/**
+ * Mensaje que viaja por la cola de messages-business para avisar en lote a los equipos.
+ * Reemplaza al `POST /private/messages/mdm-notify`, que se retira.
+ */
+class MdmNotifyQueueMessageRequest {
+}
+exports.MdmNotifyQueueMessageRequest = MdmNotifyQueueMessageRequest;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayNotEmpty)(),
+    (0, class_validator_1.ArrayMaxSize)(MdmNotifyBatchLimits_1.MDM_NOTIFY_MAX_BATCH),
+    (0, class_validator_1.ArrayUnique)((item) => item.imei),
+    (0, class_validator_1.ValidateNested)({ each: true }),
+    (0, class_transformer_1.Type)(() => MdmNotifyItem_1.MdmNotifyItem),
+    __metadata("design:type", Array)
+], MdmNotifyQueueMessageRequest.prototype, "items", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], MdmNotifyQueueMessageRequest.prototype, "tenantId", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.MaxLength)(64),
+    __metadata("design:type", String)
+], MdmNotifyQueueMessageRequest.prototype, "operationReference", void 0);

package/bin/messagesConnector/index.d.ts

@@ -23,6 +23,7 @@ export * from './dtos/TemplateMessageListFiltersRequest';
 export * from './constants/MdmNotifyBatchLimits';
 export * from './dtos/MdmNotifyItem';
 export * from './dtos/MdmNotifyRequest';
+export * from './dtos/MdmNotifyQueueMessageRequest';
 export * from './dtos/MdmNotifyResponse';
 export * from './dtos/MdmNotifyBatchResponse';
 export * from './constants/MessageIdempotencyLimits';

package/bin/messagesConnector/index.js

@@ -39,6 +39,7 @@ __exportStar(require("./dtos/TemplateMessageListFiltersRequest"), exports);
 __exportStar(require("./constants/MdmNotifyBatchLimits"), exports);
 __exportStar(require("./dtos/MdmNotifyItem"), exports);
 __exportStar(require("./dtos/MdmNotifyRequest"), exports);
+__exportStar(require("./dtos/MdmNotifyQueueMessageRequest"), exports);
 __exportStar(require("./dtos/MdmNotifyResponse"), exports);
 __exportStar(require("./dtos/MdmNotifyBatchResponse"), exports);
 __exportStar(require("./constants/MessageIdempotencyLimits"), exports);

package/bin/messagesConnector/validators/IsTemplatePlaceholders.d.ts

@@ -1,10 +1,11 @@
 import { ValidatorConstraintInterface, ValidationArguments } from 'class-validator';
 /**
- * Valida que un string solo contenga placeholders bien formados `{varName}` donde
- * `varName` matchea `^[a-zA-Z][a-zA-Z0-9_]*$`. Rechaza:
+ * Valida que un string solo contenga placeholders bien formados, en cualquiera de las dos
+ * formas del catalogo: `{varName}` o `{{varName}}`, con `varName` matcheando
+ * `^[a-zA-Z][a-zA-Z0-9_]*$`. Rechaza:
  *  - Placeholders con espacios o caracteres invalidos (`{var name}`, `{var-1}`).
- *  - Llaves sin balancear (`abc {def`, `abc } def`, `{ {nested}` ).
- *  - Placeholders vacios (`{}`).
+ *  - Llaves sin balancear (`abc {def`, `abc } def`, `{ {nested}`).
+ *  - Placeholders vacios (`{}`, `{{}}`).
  * Acepta texto sin placeholders en absoluto.
  *
  * Uso en DTOs: `@Validate(IsTemplatePlaceholders)` sobre un campo string.

package/bin/messagesConnector/validators/IsTemplatePlaceholders.js

@@ -10,11 +10,17 @@ exports.IsTemplatePlaceholders = void 0;
 const class_validator_1 = require("class-validator");
 const VALID_PLACEHOLDER = /^[a-zA-Z][a-zA-Z0-9_]*$/;
 /**
- * Valida que un string solo contenga placeholders bien formados `{varName}` donde
- * `varName` matchea `^[a-zA-Z][a-zA-Z0-9_]*$`. Rechaza:
+ * Las DOS formas que el renderizador sustituye: doble `{{monto}}` y simple `{monto}`.
+ * La doble va primero para que no gane el `{monto}` interno, igual que alla.
+ */
+const PLACEHOLDER_PATTERN = /\{\{([^{}]*)\}\}|\{([^{}]*)\}/g;
+/**
+ * Valida que un string solo contenga placeholders bien formados, en cualquiera de las dos
+ * formas del catalogo: `{varName}` o `{{varName}}`, con `varName` matcheando
+ * `^[a-zA-Z][a-zA-Z0-9_]*$`. Rechaza:
  *  - Placeholders con espacios o caracteres invalidos (`{var name}`, `{var-1}`).
- *  - Llaves sin balancear (`abc {def`, `abc } def`, `{ {nested}` ).
- *  - Placeholders vacios (`{}`).
+ *  - Llaves sin balancear (`abc {def`, `abc } def`, `{ {nested}`).
+ *  - Placeholders vacios (`{}`, `{{}}`).
  * Acepta texto sin placeholders en absoluto.
  *
  * Uso en DTOs: `@Validate(IsTemplatePlaceholders)` sobre un campo string.
@@ -23,33 +29,20 @@ let IsTemplatePlaceholders = class IsTemplatePlaceholders {
     validate(value) {
         if (typeof value !== 'string')
             return false;
-        // Detectar llaves desbalanceadas con un single-pass.
-        let depth = 0;
-        for (const ch of value) {
-            if (ch === '{') {
-                if (depth > 0)
-                    return false; // anidado no permitido
-                depth = 1;
-            }
-            else if (ch === '}') {
-                if (depth === 0)
-                    return false; // cierre sin apertura
-                depth = 0;
-            }
-        }
-        if (depth !== 0)
-            return false; // apertura sin cierre
-        // Validar que cada `{...}` matchea el regex.
-        const matches = value.match(/\{([^}]*)\}/g) ?? [];
-        for (const raw of matches) {
-            const inner = raw.slice(1, -1);
-            if (!VALID_PLACEHOLDER.test(inner))
-                return false;
-        }
-        return true;
+        // Se consumen los placeholders bien formados; lo que sobra no puede tener llaves.
+        let wellFormed = true;
+        const leftover = value.replace(PLACEHOLDER_PATTERN, (_match, doubleName, singleName) => {
+            const name = doubleName ?? singleName ?? '';
+            if (!VALID_PLACEHOLDER.test(name))
+                wellFormed = false;
+            return '';
+        });
+        if (!wellFormed)
+            return false;
+        return !leftover.includes('{') && !leftover.includes('}');
     }
     defaultMessage(args) {
-        return `${args.property} contiene placeholders mal formados; debe seguir el patron {nombre} con nombre = [a-zA-Z][a-zA-Z0-9_]*`;
+        return `${args.property} contiene placeholders mal formados; debe seguir el patron {nombre} o {{nombre}} con nombre = [a-zA-Z][a-zA-Z0-9_]*`;
     }
 };
 exports.IsTemplatePlaceholders = IsTemplatePlaceholders;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiado/type-kit",
-  "version": "3.419.0",
+  "version": "3.421.0",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",

package/src/messagesConnector/dtos/MdmNotifyQueueMessageRequest.ts

@@ -0,0 +1,37 @@
+import { Expose, Type } from 'class-transformer';
+import { ArrayMaxSize, ArrayNotEmpty, ArrayUnique, IsArray, IsNotEmpty, IsOptional, IsString, MaxLength, ValidateNested } from 'class-validator';
+import { MdmNotifyItem } from './MdmNotifyItem';
+import { MDM_NOTIFY_MAX_BATCH } from '../constants/MdmNotifyBatchLimits';
+
+/**
+ * Mensaje que viaja por la cola de messages-business para avisar en lote a los equipos.
+ * Reemplaza al `POST /private/messages/mdm-notify`, que se retira.
+ */
+export class MdmNotifyQueueMessageRequest {
+    /**
+     * Equipos del lote. El tope es el mismo que el del lote de `loan-credit-business`.
+     * El imei repetido duplica el aviso en el equipo y colapsa los dos acuses en uno.
+     */
+    @Expose()
+    @IsArray()
+    @ArrayNotEmpty()
+    @ArrayMaxSize(MDM_NOTIFY_MAX_BATCH)
+    @ArrayUnique((item: MdmNotifyItem) => item.imei)
+    @ValidateNested({ each: true })
+    @Type(() => MdmNotifyItem)
+    items!: MdmNotifyItem[];
+
+    /** Tenant emisor del aviso. Si se omite, messages-business asume FIADO. */
+    @Expose()
+    @IsOptional()
+    @IsString()
+    @IsNotEmpty()
+    tenantId?: string;
+
+    /** Referencia con la que el productor correlaciona este lote. Es la que viaja al proveedor. */
+    @Expose()
+    @IsString()
+    @IsNotEmpty()
+    @MaxLength(64)
+    operationReference!: string;
+}

package/src/messagesConnector/index.ts

@@ -23,6 +23,7 @@ export * from './dtos/TemplateMessageListFiltersRequest';
 export * from './constants/MdmNotifyBatchLimits';
 export * from './dtos/MdmNotifyItem';
 export * from './dtos/MdmNotifyRequest';
+export * from './dtos/MdmNotifyQueueMessageRequest';
 export * from './dtos/MdmNotifyResponse';
 export * from './dtos/MdmNotifyBatchResponse';
 export * from './constants/MessageIdempotencyLimits';

package/src/messagesConnector/validators/IsTemplatePlaceholders.ts

@@ -3,11 +3,18 @@ import { ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments
 const VALID_PLACEHOLDER = /^[a-zA-Z][a-zA-Z0-9_]*$/;
 
 /**
- * Valida que un string solo contenga placeholders bien formados `{varName}` donde
- * `varName` matchea `^[a-zA-Z][a-zA-Z0-9_]*$`. Rechaza:
+ * Las DOS formas que el renderizador sustituye: doble `{{monto}}` y simple `{monto}`.
+ * La doble va primero para que no gane el `{monto}` interno, igual que alla.
+ */
+const PLACEHOLDER_PATTERN = /\{\{([^{}]*)\}\}|\{([^{}]*)\}/g;
+
+/**
+ * Valida que un string solo contenga placeholders bien formados, en cualquiera de las dos
+ * formas del catalogo: `{varName}` o `{{varName}}`, con `varName` matcheando
+ * `^[a-zA-Z][a-zA-Z0-9_]*$`. Rechaza:
  *  - Placeholders con espacios o caracteres invalidos (`{var name}`, `{var-1}`).
- *  - Llaves sin balancear (`abc {def`, `abc } def`, `{ {nested}` ).
- *  - Placeholders vacios (`{}`).
+ *  - Llaves sin balancear (`abc {def`, `abc } def`, `{ {nested}`).
+ *  - Placeholders vacios (`{}`, `{{}}`).
  * Acepta texto sin placeholders en absoluto.
  *
  * Uso en DTOs: `@Validate(IsTemplatePlaceholders)` sobre un campo string.
@@ -17,29 +24,19 @@ export class IsTemplatePlaceholders implements ValidatorConstraintInterface {
     validate(value: unknown): boolean {
         if (typeof value !== 'string') return false;
 
-        // Detectar llaves desbalanceadas con un single-pass.
-        let depth = 0;
-        for (const ch of value) {
-            if (ch === '{') {
-                if (depth > 0) return false; // anidado no permitido
-                depth = 1;
-            } else if (ch === '}') {
-                if (depth === 0) return false; // cierre sin apertura
-                depth = 0;
-            }
-        }
-        if (depth !== 0) return false; // apertura sin cierre
+        // Se consumen los placeholders bien formados; lo que sobra no puede tener llaves.
+        let wellFormed = true;
+        const leftover = value.replace(PLACEHOLDER_PATTERN, (_match, doubleName?: string, singleName?: string) => {
+            const name = doubleName ?? singleName ?? '';
+            if (!VALID_PLACEHOLDER.test(name)) wellFormed = false;
+            return '';
+        });
+        if (!wellFormed) return false;
 
-        // Validar que cada `{...}` matchea el regex.
-        const matches = value.match(/\{([^}]*)\}/g) ?? [];
-        for (const raw of matches) {
-            const inner = raw.slice(1, -1);
-            if (!VALID_PLACEHOLDER.test(inner)) return false;
-        }
-        return true;
+        return !leftover.includes('{') && !leftover.includes('}');
     }
 
     defaultMessage(args: ValidationArguments): string {
-        return `${args.property} contiene placeholders mal formados; debe seguir el patron {nombre} con nombre = [a-zA-Z][a-zA-Z0-9_]*`;
+        return `${args.property} contiene placeholders mal formados; debe seguir el patron {nombre} o {{nombre}} con nombre = [a-zA-Z][a-zA-Z0-9_]*`;
     }
 }