tychat-contracts 1.0.106 → 1.0.108

package/dist/conversations/conversation-contact-filters-query.validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conversation-contact-filters-query.validator.d.ts","sourceRoot":"","sources":["../../src/conversations/conversation-contact-filters-query.validator.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,mBAAmB,EAGnB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AAoBzB;;;;;;;GAOG;AACH,qBACa,yCACX,YAAW,4BAA4B;IAEvC,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAwH5D,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM;CAMlD"}
+{"version":3,"file":"conversation-contact-filters-query.validator.d.ts","sourceRoot":"","sources":["../../src/conversations/conversation-contact-filters-query.validator.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,mBAAmB,EAGnB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AA8CzB;;;;;;;GAOG;AACH,qBACa,yCACX,YAAW,4BAA4B;IAEvC,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAyH5D,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM;CAMlD"}

package/dist/conversations/conversation-contact-filters-query.validator.js

@@ -25,6 +25,30 @@ function flattenErrors(errors, prefix = '') {
     }
     return out;
 }
+/** Alguns gateways/parsers envolvem o item em um ou mais arrays de um elemento. */
+function unwrapSingleElementArrays(el, maxDepth = 8) {
+    let cur = el;
+    let d = 0;
+    while (Array.isArray(cur) && cur.length === 1 && d < maxDepth) {
+        cur = cur[0];
+        d += 1;
+    }
+    return cur;
+}
+/** JSON string que, ao dar parse, ainda é string (double-encoded), até virar objeto/array. */
+function jsonParseLoose(text) {
+    let parsed = JSON.parse(text);
+    let guard = 0;
+    while (typeof parsed === 'string' && guard < 4) {
+        const s = parsed.trim();
+        if (s === '') {
+            break;
+        }
+        parsed = JSON.parse(s);
+        guard += 1;
+    }
+    return parsed;
+}
 /**
  * Aceita na query (e no payload Kafka já desserializado):
  * - array de strings: cada string é JSON de um objeto `{ key, op, value }`
@@ -50,7 +74,7 @@ let ConversationContactFiltersQueryConstraint = class ConversationContactFilters
             }
             let parsed;
             try {
-                parsed = JSON.parse(t);
+                parsed = jsonParseLoose(t);
             }
             catch {
                 conversationContactFiltersQueryError.set(parent, 'filters: string não é JSON válido');
@@ -83,7 +107,7 @@ let ConversationContactFiltersQueryConstraint = class ConversationContactFilters
         }
         const out = [];
         for (let i = 0; i < rawItems.length; i++) {
-            const el = rawItems[i];
+            const el = unwrapSingleElementArrays(rawItems[i]);
             let plain;
             if (typeof el === 'string') {
                 const s = el.trim();
@@ -92,18 +116,19 @@ let ConversationContactFiltersQueryConstraint = class ConversationContactFilters
                     return false;
                 }
                 try {
-                    plain = JSON.parse(s);
+                    plain = jsonParseLoose(s);
                 }
                 catch {
                     conversationContactFiltersQueryError.set(parent, `filters[${i}]: JSON inválido`);
                     return false;
                 }
+                plain = unwrapSingleElementArrays(plain);
             }
             else if (el !== null && typeof el === 'object' && !Array.isArray(el)) {
                 plain = el;
             }
             else {
-                conversationContactFiltersQueryError.set(parent, `filters[${i}] deve ser string JSON ou objeto`);
+                conversationContactFiltersQueryError.set(parent, `filters[${i}] deve ser string JSON, objeto, ou array de um único filtro (formato recebido inválido)`);
                 return false;
             }
             if (plain === null ||

package/dist/conversations/conversation-contact-filters-query.validator.spec.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=conversation-contact-filters-query.validator.spec.d.ts.map

package/dist/conversations/conversation-contact-filters-query.validator.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-contact-filters-query.validator.spec.d.ts","sourceRoot":"","sources":["../../src/conversations/conversation-contact-filters-query.validator.spec.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/conversations/conversation-contact-filters-query.validator.spec.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const list_conversation_contacts_query_dto_1 = require("./list-conversation-contacts-query.dto");
+/**
+ * Simulates how NestJS ValidationPipe processes a raw query object
+ * when configured with transform: true and enableImplicitConversion: true.
+ */
+function simulateValidationPipe(raw) {
+    return (0, class_transformer_1.plainToInstance)(list_conversation_contacts_query_dto_1.ListConversationContactsQueryDto, raw, {
+        enableImplicitConversion: true,
+    });
+}
+describe('ConversationContactFiltersQueryConstraint', () => {
+    it('should accept a single JSON object string (URL-decoded query param)', async () => {
+        const raw = {
+            page: '1',
+            limit: '20',
+            filters: '{"key":"intention","op":"==","value":"clinic_info"}',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toEqual([
+            expect.objectContaining({
+                key: 'intention',
+                op: '==',
+                value: 'clinic_info',
+            }),
+        ]);
+    });
+    it('should accept a JSON array string with one filter', async () => {
+        const raw = {
+            page: '1',
+            limit: '20',
+            filters: '[{"key":"intention","op":"==","value":"clinic_info"}]',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toHaveLength(1);
+    });
+    it('should accept a JSON array string with multiple filters', async () => {
+        const raw = {
+            filters: '[{"key":"intention","op":"==","value":"clinic_info"},{"key":"patientId","op":"!=","value":"abc"}]',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toHaveLength(2);
+    });
+    it('should accept an array of JSON strings (e.g. filters[0]=...&filters[1]=...)', async () => {
+        const raw = {
+            filters: [
+                '{"key":"intention","op":"==","value":"clinic_info"}',
+                '{"key":"patientId","op":"!=","value":"xyz"}',
+            ],
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toHaveLength(2);
+    });
+    it('should accept an array of plain objects (Kafka / programmatic usage)', async () => {
+        const raw = {
+            filters: [
+                { key: 'intention', op: '==', value: 'clinic_info' },
+            ],
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toHaveLength(1);
+    });
+    it('should accept a single plain object', async () => {
+        const raw = {
+            filters: { key: 'intention', op: '==', value: 'clinic_info' },
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toHaveLength(1);
+    });
+    it('should accept undefined/null filters', async () => {
+        const dto = simulateValidationPipe({ page: '1', limit: '20' });
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toBeUndefined();
+    });
+    it('should accept empty string filters', async () => {
+        const dto = simulateValidationPipe({ filters: '' });
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toBeUndefined();
+    });
+    it('should reject invalid JSON string', async () => {
+        const dto = simulateValidationPipe({ filters: '{bad json' });
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should reject a filter with invalid key', async () => {
+        const raw = {
+            filters: '{"key":"invalidField","op":"==","value":"x"}',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should reject a filter with invalid operator', async () => {
+        const raw = {
+            filters: '{"key":"intention","op":"like","value":"x"}',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should accept op "in" with array value', async () => {
+        const raw = {
+            filters: '{"key":"intention","op":"in","value":["clinic_info","other"]}',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+    });
+    it('should reject op "in" with scalar value', async () => {
+        const raw = {
+            filters: '{"key":"intention","op":"in","value":"clinic_info"}',
+        };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors.length).toBeGreaterThan(0);
+    });
+    it('should handle double-encoded JSON string', async () => {
+        const inner = JSON.stringify({
+            key: 'intention',
+            op: '==',
+            value: 'clinic_info',
+        });
+        const raw = { filters: JSON.stringify(inner) };
+        const dto = simulateValidationPipe(raw);
+        const errors = await (0, class_validator_1.validate)(dto, {
+            whitelist: true,
+            forbidNonWhitelisted: true,
+        });
+        expect(errors).toHaveLength(0);
+        expect(dto.filters).toHaveLength(1);
+    });
+});

package/dist/conversations/list-conversation-contacts-query.dto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-conversation-contacts-query.dto.d.ts","sourceRoot":"","sources":["../../src/conversations/list-conversation-contacts-query.dto.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAE5F,qBAAa,gCAAgC;IAU3C,IAAI,CAAC,EAAE,MAAM,CAAC;IAad,KAAK,CAAC,EAAE,MAAM,CAAC;IAWf,OAAO,CAAC,EAAE,gCAAgC,EAAE,CAAC;CAC9C"}
+{"version":3,"file":"list-conversation-contacts-query.dto.d.ts","sourceRoot":"","sources":["../../src/conversations/list-conversation-contacts-query.dto.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAqB5F,qBAAa,gCAAgC;IAU3C,IAAI,CAAC,EAAE,MAAM,CAAC;IAad,KAAK,CAAC,EAAE,MAAM,CAAC;IAYf,OAAO,CAAC,EAAE,gCAAgC,EAAE,CAAC;CAC9C"}

package/dist/conversations/list-conversation-contacts-query.dto.js

@@ -13,6 +13,24 @@ exports.ListConversationContactsQueryDto = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const conversation_contact_filters_query_validator_1 = require("./conversation-contact-filters-query.validator");
+/**
+ * Overrides TypeScript's reflected `design:type` metadata to `Object`.
+ *
+ * When `enableImplicitConversion` is true, class-transformer uses the reflected
+ * type to recursively transform array elements. For properties like `filters`
+ * whose raw value (string / mixed array) is fully parsed by a custom validator,
+ * the implicit conversion mangles the value before the validator sees it.
+ *
+ * Placing this decorator **first** (topmost) ensures it runs **last** in the
+ * decorator chain, overriding the `__metadata("design:type", Array)` emitted
+ * by TypeScript. With `design:type = Object`, class-transformer leaves the raw
+ * value intact.
+ */
+function RawQueryParam() {
+    return (target, propertyKey) => {
+        Reflect.defineMetadata('design:type', Object, target, propertyKey);
+    };
+}
 class ListConversationContactsQueryDto {
     page;
     limit;
@@ -52,6 +70,8 @@ __decorate([
         items: { type: 'string' },
         example: ['{"key":"intention","op":"==","value":"clinic_info"}'],
     }),
+    RawQueryParam() // Must be first — overrides design:type from Array to Object so class-transformer won't mangle the value
+    ,
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.Validate)(conversation_contact_filters_query_validator_1.ConversationContactFiltersQueryConstraint),
     __metadata("design:type", Array)

package/jest.config.ts

@@ -0,0 +1,5 @@
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tychat-contracts",
-  "version": "1.0.106",
+  "version": "1.0.108",
   "description": "DTOs compartilhados com class-validator (API e microserviços)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,6 +18,8 @@
   },
   "devDependencies": {
     "@nestjs/swagger": "^11.2.6",
+    "@types/jest": "^30.0.0",
+    "ts-jest": "^29.4.9",
     "typescript": "^5.7.3"
   },
   "peerDependencies": {

package/scripts/debug-filters-transform.js

@@ -0,0 +1,29 @@
+require('reflect-metadata');
+const { plainToInstance } = require('class-transformer');
+const { validateSync } = require('class-validator');
+const {
+  ListConversationContactsQueryDto,
+} = require('../dist/conversations/list-conversation-contacts-query.dto.js');
+
+const obj = {
+  key: 'intention',
+  op: '==',
+  value: 'clinic_info',
+};
+const r = plainToInstance(
+  ListConversationContactsQueryDto,
+  { page: '1', limit: '20', filters: obj },
+  { enableImplicitConversion: true },
+);
+const errors = validateSync(r, {
+  whitelist: true,
+  forbidNonWhitelisted: true,
+});
+process.stdout.write('errors=' + JSON.stringify(errors) + '\n');
+process.stdout.write(
+  'len=' +
+    String(r.filters?.length) +
+    ' isArray=' +
+    String(Array.isArray(r.filters)) +
+    '\n',
+);

package/src/conversations/conversation-contact-filters-query.validator.spec.ts

@@ -0,0 +1,205 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { ListConversationContactsQueryDto } from './list-conversation-contacts-query.dto';
+
+/**
+ * Simulates how NestJS ValidationPipe processes a raw query object
+ * when configured with transform: true and enableImplicitConversion: true.
+ */
+function simulateValidationPipe(
+  raw: Record<string, unknown>,
+): ListConversationContactsQueryDto {
+  return plainToInstance(ListConversationContactsQueryDto, raw, {
+    enableImplicitConversion: true,
+  });
+}
+
+describe('ConversationContactFiltersQueryConstraint', () => {
+  it('should accept a single JSON object string (URL-decoded query param)', async () => {
+    const raw = {
+      page: '1',
+      limit: '20',
+      filters: '{"key":"intention","op":"==","value":"clinic_info"}',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toEqual([
+      expect.objectContaining({
+        key: 'intention',
+        op: '==',
+        value: 'clinic_info',
+      }),
+    ]);
+  });
+
+  it('should accept a JSON array string with one filter', async () => {
+    const raw = {
+      page: '1',
+      limit: '20',
+      filters: '[{"key":"intention","op":"==","value":"clinic_info"}]',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toHaveLength(1);
+  });
+
+  it('should accept a JSON array string with multiple filters', async () => {
+    const raw = {
+      filters:
+        '[{"key":"intention","op":"==","value":"clinic_info"},{"key":"patientId","op":"!=","value":"abc"}]',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toHaveLength(2);
+  });
+
+  it('should accept an array of JSON strings (e.g. filters[0]=...&filters[1]=...)', async () => {
+    const raw = {
+      filters: [
+        '{"key":"intention","op":"==","value":"clinic_info"}',
+        '{"key":"patientId","op":"!=","value":"xyz"}',
+      ],
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toHaveLength(2);
+  });
+
+  it('should accept an array of plain objects (Kafka / programmatic usage)', async () => {
+    const raw = {
+      filters: [
+        { key: 'intention', op: '==', value: 'clinic_info' },
+      ],
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toHaveLength(1);
+  });
+
+  it('should accept a single plain object', async () => {
+    const raw = {
+      filters: { key: 'intention', op: '==', value: 'clinic_info' },
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toHaveLength(1);
+  });
+
+  it('should accept undefined/null filters', async () => {
+    const dto = simulateValidationPipe({ page: '1', limit: '20' });
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toBeUndefined();
+  });
+
+  it('should accept empty string filters', async () => {
+    const dto = simulateValidationPipe({ filters: '' });
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toBeUndefined();
+  });
+
+  it('should reject invalid JSON string', async () => {
+    const dto = simulateValidationPipe({ filters: '{bad json' });
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should reject a filter with invalid key', async () => {
+    const raw = {
+      filters: '{"key":"invalidField","op":"==","value":"x"}',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should reject a filter with invalid operator', async () => {
+    const raw = {
+      filters: '{"key":"intention","op":"like","value":"x"}',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should accept op "in" with array value', async () => {
+    const raw = {
+      filters: '{"key":"intention","op":"in","value":["clinic_info","other"]}',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+  });
+
+  it('should reject op "in" with scalar value', async () => {
+    const raw = {
+      filters: '{"key":"intention","op":"in","value":"clinic_info"}',
+    };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('should handle double-encoded JSON string', async () => {
+    const inner = JSON.stringify({
+      key: 'intention',
+      op: '==',
+      value: 'clinic_info',
+    });
+    const raw = { filters: JSON.stringify(inner) };
+    const dto = simulateValidationPipe(raw);
+    const errors = await validate(dto, {
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    });
+    expect(errors).toHaveLength(0);
+    expect(dto.filters).toHaveLength(1);
+  });
+});

package/src/conversations/conversation-contact-filters-query.validator.ts

@@ -25,6 +25,32 @@ function flattenErrors(errors: ValidationError[], prefix = ''): string[] {
   return out;
 }
 
+/** Alguns gateways/parsers envolvem o item em um ou mais arrays de um elemento. */
+function unwrapSingleElementArrays(el: unknown, maxDepth = 8): unknown {
+  let cur = el;
+  let d = 0;
+  while (Array.isArray(cur) && cur.length === 1 && d < maxDepth) {
+    cur = cur[0];
+    d += 1;
+  }
+  return cur;
+}
+
+/** JSON string que, ao dar parse, ainda é string (double-encoded), até virar objeto/array. */
+function jsonParseLoose(text: string): unknown {
+  let parsed: unknown = JSON.parse(text);
+  let guard = 0;
+  while (typeof parsed === 'string' && guard < 4) {
+    const s = parsed.trim();
+    if (s === '') {
+      break;
+    }
+    parsed = JSON.parse(s);
+    guard += 1;
+  }
+  return parsed;
+}
+
 /**
  * Aceita na query (e no payload Kafka já desserializado):
  * - array de strings: cada string é JSON de um objeto `{ key, op, value }`
@@ -55,7 +81,7 @@ export class ConversationContactFiltersQueryConstraint
       }
       let parsed: unknown;
       try {
-        parsed = JSON.parse(t);
+        parsed = jsonParseLoose(t);
       } catch {
         conversationContactFiltersQueryError.set(
           parent,
@@ -96,7 +122,7 @@ export class ConversationContactFiltersQueryConstraint
 
     const out: ConversationContactListFilterDto[] = [];
     for (let i = 0; i < rawItems.length; i++) {
-      const el = rawItems[i];
+      const el = unwrapSingleElementArrays(rawItems[i]);
       let plain: unknown;
       if (typeof el === 'string') {
         const s = el.trim();
@@ -108,7 +134,7 @@ export class ConversationContactFiltersQueryConstraint
           return false;
         }
         try {
-          plain = JSON.parse(s);
+          plain = jsonParseLoose(s);
         } catch {
           conversationContactFiltersQueryError.set(
             parent,
@@ -116,12 +142,13 @@ export class ConversationContactFiltersQueryConstraint
           );
           return false;
         }
+        plain = unwrapSingleElementArrays(plain);
       } else if (el !== null && typeof el === 'object' && !Array.isArray(el)) {
         plain = el;
       } else {
         conversationContactFiltersQueryError.set(
           parent,
-          `filters[${i}] deve ser string JSON ou objeto`,
+          `filters[${i}] deve ser string JSON, objeto, ou array de um único filtro (formato recebido inválido)`,
         );
         return false;
       }

package/src/conversations/list-conversation-contacts-query.dto.ts

@@ -3,6 +3,25 @@ import { IsInt, IsOptional, Max, Min, Validate } from 'class-validator';
 import { ConversationContactFiltersQueryConstraint } from './conversation-contact-filters-query.validator';
 import { ConversationContactListFilterDto } from './list-conversation-contacts-filters.dto';
 
+/**
+ * Overrides TypeScript's reflected `design:type` metadata to `Object`.
+ *
+ * When `enableImplicitConversion` is true, class-transformer uses the reflected
+ * type to recursively transform array elements. For properties like `filters`
+ * whose raw value (string / mixed array) is fully parsed by a custom validator,
+ * the implicit conversion mangles the value before the validator sees it.
+ *
+ * Placing this decorator **first** (topmost) ensures it runs **last** in the
+ * decorator chain, overriding the `__metadata("design:type", Array)` emitted
+ * by TypeScript. With `design:type = Object`, class-transformer leaves the raw
+ * value intact.
+ */
+function RawQueryParam(): PropertyDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata('design:type', Object, target, propertyKey);
+  };
+}
+
 export class ListConversationContactsQueryDto {
   @ApiPropertyOptional({
     description: 'Número da página (iniciando em 1)',
@@ -35,6 +54,7 @@ export class ListConversationContactsQueryDto {
     items: { type: 'string' },
     example: ['{"key":"intention","op":"==","value":"clinic_info"}'],
   })
+  @RawQueryParam() // Must be first — overrides design:type from Array to Object so class-transformer won't mangle the value
   @IsOptional()
   @Validate(ConversationContactFiltersQueryConstraint)
   filters?: ConversationContactListFilterDto[];