tychat-contracts 1.0.107 → 1.0.109

package/dist/analytics/analytics-query.dto.js

@@ -127,7 +127,7 @@ __decorate([
 ], AnalyticsDashboardFinancialDto.prototype, "averageTicket", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
-        description: 'Valor ainda em aberto no fim do período (exclusive endDate): soma de `payment.created` no intervalo sem `payment.payed` correspondente (mesmo paymentId) com occurredAt anterior a endDate; mais faturas `billing.invoice_created` PENDING/OVERDUE sem `billing.invoice_paid` (mesmo invoiceId). Baseado em eventos de analytics.',
+        description: 'Valor total de procedimentos dos agendamentos ainda pendentes (status pending/processing/sended) no período: soma de `appointment_procedures.value` via JOIN com `appointments`.',
     }),
     __metadata("design:type", Number)
 ], AnalyticsDashboardFinancialDto.prototype, "pending", void 0);
@@ -220,7 +220,7 @@ __decorate([
 ], AnalyticsDashboardResponseDto.prototype, "appointmentsFinished", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
-        description: 'Procedimentos agendados: soma dos itens em metadata.procedures em `appointment.created` + vínculos posteriores (`appointment.updated` com reason procedure_added)',
+        description: 'Procedimentos agendados: total de registros em `appointment_procedures` cujo agendamento (`appointments.date`) está no período',
     }),
     __metadata("design:type", Number)
 ], AnalyticsDashboardResponseDto.prototype, "proceduresScheduled", void 0);

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.107",
+  "version": "1.0.109",
   "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/analytics/analytics-query.dto.ts

@@ -104,7 +104,7 @@ export class AnalyticsDashboardFinancialDto {
 
   @ApiProperty({
     description:
-      'Valor ainda em aberto no fim do período (exclusive endDate): soma de `payment.created` no intervalo sem `payment.payed` correspondente (mesmo paymentId) com occurredAt anterior a endDate; mais faturas `billing.invoice_created` PENDING/OVERDUE sem `billing.invoice_paid` (mesmo invoiceId). Baseado em eventos de analytics.',
+      'Valor total de procedimentos dos agendamentos ainda pendentes (status pending/processing/sended) no período: soma de `appointment_procedures.value` via JOIN com `appointments`.',
   })
   pending: number;
 }
@@ -159,7 +159,7 @@ export class AnalyticsDashboardResponseDto {
 
   @ApiProperty({
     description:
-      'Procedimentos agendados: soma dos itens em metadata.procedures em `appointment.created` + vínculos posteriores (`appointment.updated` com reason procedure_added)',
+      'Procedimentos agendados: total de registros em `appointment_procedures` cujo agendamento (`appointments.date`) está no período',
   })
   proceduresScheduled: number;
 

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/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[];