@solidxai/core 0.1.17 → 0.1.18-beta.0

package/src/helpers/field-crud-managers/SelectionStaticFieldCrudManager.ts

@@ -26,7 +26,7 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
                 return [
                     {
                         field: this.options.fieldName,
-                        error: `Field: ${this.options.fieldName} must be a valid array`,
+                        error: `Field: ${this.options.fieldName} must be a valid string representation of a JSON array of selection values. Allowed values: '${this.formatAllowedValues()}'. Received: ${this.formatValue(fieldValue)}`,
                     },
                 ];
             }
@@ -43,7 +43,7 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
             }
 
             // Apply validations to each value
-            const allErrors = await Promise.all(values.map((val) => this.applyValidations(val)));
+            const allErrors = await Promise.all(values.map((val) => this.applyValidations(val, values)));
             return allErrors.flat();
         } else {
             // For non-multi-select, apply validations to the single field value
@@ -69,22 +69,47 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
     }
     
 
-    private applyValidations(fieldValue: any): ValidationError[] {
+    private applyValidations(fieldValue: any, receivedValue: any = fieldValue): ValidationError[] {
         const errors: ValidationError[] = [];
         this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";
         if (isNotEmpty(fieldValue)) {
-            errors.push(...this.applyFormatValidations(fieldValue));
+            errors.push(...this.applyFormatValidations(fieldValue, receivedValue));
         }
         return errors;
     }
 
-    private applyFormatValidations(fieldValue: any): ValidationError[] {
+    private applyFormatValidations(fieldValue: any, receivedValue: any = fieldValue): ValidationError[] {
         const errors: ValidationError[] = [];
-        !this.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
-        !this.isValidSelectionStaticValue(fieldValue, this.options.selectionValueType, this.options.selectionStaticValues) ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        const allowedValues = this.formatAllowedValues();
+        const received = this.formatValue(receivedValue);
+        !this.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({
+            field: this.options.fieldName,
+            error: `Field: ${this.options.fieldName} has an invalid selection value type. Expected ${this.options.selectionValueType}. Allowed values: ${allowedValues}. Received: ${received}`,
+        }) : "no errors";
+        !this.isValidSelectionStaticValue(fieldValue, this.options.selectionValueType, this.options.selectionStaticValues) ? errors.push({
+            field: this.options.fieldName,
+            error: `Field: ${this.options.fieldName} contains an invalid selection value. Allowed values: ${allowedValues}. Received: ${received}`,
+        }) : "no errors";
         return errors;
     }
 
+    private formatAllowedValues(): string {
+        const values = this.options.selectionStaticValues.map((value) => {
+            const rawValue = value.split(":")[0];
+            return this.options.selectionValueType === SelectionValueType.int ? Number(rawValue) : rawValue;
+        });
+        return this.formatValue(values);
+    }
+
+    private formatValue(value: any): string {
+        try {
+            const formatted = JSON.stringify(value);
+            return formatted === undefined ? String(value) : formatted;
+        } catch {
+            return String(value);
+        }
+    }
+
     transformForCreate(dto: any): any {
         return dto;
     }

package/src/index.ts

@@ -29,6 +29,7 @@ export * from './decorators/security-rule-config-provider.decorator'
 export * from './decorators/sms-provider.decorator'
 export * from './decorators/settings-provider.decorator'
 export * from './decorators/extension-user-creation-provider.decorator'
+export * from './decorators/whatsapp-provider.decorator'
 export * from './decorators/workflow-node-provider.decorator'
 export * from './decorators/workflow-field-data-provider.decorator'
 

package/src/services/crud.service.ts

@@ -300,15 +300,23 @@ private async prepareManyToManyAuditSnapshot(entity: T,id: number,modelSingularN
             field.relationType !== 'one-to-many'
         );
         if (auditRelationFields.length > 0) {
-            const relations: any = {};
-            auditRelationFields.forEach(field => relations[field.name] = true);
+            // Fetch each audit-tracked relation independently rather than joining all of
+            // them into a single query: for an entity with several many-to-many
+            // relations, one combined query multiplies row counts across every joined
+            // relation at once and can blow past the statement timeout as data grows.
             const auditBeforeEntity = await this.repo.findOne({
                 where: {
                     id: id,
                 } as unknown as FindOptionsWhere<T>,
-                relations: relations as any,
             });
             if (auditBeforeEntity) {
+                for (const field of auditRelationFields) {
+                    (auditBeforeEntity as any)[field.name] = await this.repo.manager
+                        .createQueryBuilder()
+                        .relation(this.repo.target, field.name)
+                        .of(id)
+                        .loadMany();
+                }
                 Object.defineProperty(entity, AUDIT_BEFORE_SNAPSHOT, {
                     configurable: true,
                     enumerable: false,

package/src/subscribers/audit.subscriber.ts

@@ -98,19 +98,26 @@ export class AuditSubscriber implements EntitySubscriberInterface {
             return null;
         }
 
-        const relations: Record<string, boolean> = {};
-
-        auditRelationFields.forEach(field => {
-            relations[field.name] = true;
-        });
-
         const relationBefore = event.entity?.[AUDIT_BEFORE_SNAPSHOT] ?? null;
 
-        const relationAfter = await event.queryRunner.manager.getRepository(event.metadata.target as any).findOne({
+        // Same fix as CRUDService.prepareManyToManyAuditSnapshot: load each audit-tracked
+        // relation independently instead of joining them all into one query, so the row
+        // count of one relation doesn't multiply against every other joined relation.
+        const targetRepo = event.queryRunner.manager.getRepository(event.metadata.target as any);
+        const relationAfter = await targetRepo.findOne({
             where: { id: entityId } as any,
-            relations: relations as any,
         });
 
+        if (relationAfter) {
+            for (const field of auditRelationFields) {
+                (relationAfter as any)[field.name] = await event.queryRunner.manager
+                    .createQueryBuilder()
+                    .relation(event.metadata.target as any, field.name)
+                    .of(entityId)
+                    .loadMany();
+            }
+        }
+
         if (relationBefore && relationAfter) {
             auditRelationFields.forEach(field => {
                 const oldIds = Array.isArray(relationBefore[field.name])