@hed-hog/core 0.0.300 → 0.0.302

package/src/setting/setting.service.ts

@@ -11,11 +11,21 @@ import {
     NotFoundException
 } from '@nestjs/common';
 import * as pako from 'pako';
+import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
 import { CreateDTO } from './dto/create.dto';
 import { DeleteDTO } from './dto/delete.dto';
 import { SettingDTO } from './dto/setting.dto';
 import { UpdateDTO } from './dto/update.dto';
 
+type SettingChangeEventInput = {
+  settingId?: number | null;
+  slug: string;
+  type?: string | null;
+  oldValue?: any;
+  newValue?: any;
+  source: string;
+};
+
 @Injectable()
 export class SettingService {
 
@@ -29,6 +39,8 @@ export class SettingService {
     private readonly paginationService: PaginationService,
     @Inject(forwardRef(() => LocaleService))
     private readonly localeService: LocaleService,
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
   ) { }
 
   async exportSettings(includeSecrets = false): Promise<Buffer> {
@@ -108,32 +120,47 @@ export class SettingService {
         id: true,
         slug: true,
         type: true,
+        value: true,
       },
     });
 
     const transaction = [];
+    const changedSettings: SettingChangeEventInput[] = [];
+
     for (const setting of settings) {
       const existingSetting = existingSettings.find((s) => s.slug === setting.slug);
       if (existingSetting) {
+        const nextValue = this.setValueFormattedByType(existingSetting.type, setting.value);
+
         transaction.push(
           this.prismaService.setting.update({
             where: {
               id: existingSetting.id,
             },
             data: {
-              value: this.setValueFormattedByType(existingSetting.type, setting.value),
+              value: nextValue,
             },
           }),
         );
+
+        changedSettings.push({
+          settingId: existingSetting.id,
+          slug: existingSetting.slug,
+          type: existingSetting.type,
+          oldValue: existingSetting.value,
+          newValue: nextValue,
+          source: 'confirmImport',
+        });
       }
     }
 
     if (transaction.length > 0) {
       await this.prismaService.$transaction(transaction);
+      await this.emitSettingChangedEvents(changedSettings);
     }
 
-    return { 
-      success: true, 
+    return {
+      success: true,
       updatedCount: transaction.length,
     };
   }
@@ -178,6 +205,8 @@ export class SettingService {
       'password-min-uppercase',
       'password-min-length',
       'mfa-email-code-length',
+      'ai-openai-api-key-enabled',
+      'ai-gemini-api-key-enabled',
       'date-format',
       'time-format',
       'timezone',
@@ -233,21 +262,52 @@ export class SettingService {
   async setManySettings(data: SettingDTO) {
     this.clearCache();
     const transaction = [];
+    const existingSettings = await this.prismaService.setting.findMany({
+      where: {
+        slug: {
+          in: data.setting.map((item) => item.slug),
+        },
+      },
+      select: {
+        id: true,
+        slug: true,
+        type: true,
+        value: true,
+      },
+    });
+    const changedSettings: SettingChangeEventInput[] = [];
 
     for (const { slug, value } of data.setting) {
+      const existingSetting = existingSettings.find((item) => item.slug === slug);
+      if (!existingSetting) {
+        continue;
+      }
+
+      const nextValue = this.setValueFormattedByType(existingSetting.type, value);
+
       transaction.push(
         this.prismaService.setting.updateMany({
           where: {
             slug,
           },
           data: {
-            value,
+            value: nextValue,
           },
         }),
       );
+
+      changedSettings.push({
+        settingId: existingSetting.id,
+        slug: existingSetting.slug,
+        type: existingSetting.type,
+        oldValue: existingSetting.value,
+        newValue: nextValue,
+        source: 'setManySettings',
+      });
     }
 
     await this.prismaService.$transaction(transaction);
+    await this.emitSettingChangedEvents(changedSettings);
     return { success: true };
   }
 
@@ -477,7 +537,7 @@ export class SettingService {
 
   async create(data: CreateDTO, _locale: string) {
     this.clearCache();
-    return this.prismaService.setting.create({
+    const createdSetting = await this.prismaService.setting.create({
       data: {
         slug: data.slug,
         type: data.type as any,
@@ -490,21 +550,42 @@ export class SettingService {
         },
       },
     });
+
+    await this.emitSettingChangedEvents([
+      {
+        settingId: createdSetting.id,
+        slug: createdSetting.slug,
+        type: createdSetting.type,
+        oldValue: undefined,
+        newValue: createdSetting.value,
+        source: 'create',
+      },
+    ]);
+
+    return createdSetting;
   }
 
   async update({ id, data }: { id: number; data: UpdateDTO }) {
     this.clearCache();
 
-    const { type } = await this.prismaService.setting.findFirst({
+    const currentSetting = await this.prismaService.setting.findFirst({
       where: {
         id,
       },
+      select: {
+        id: true,
+        slug: true,
+        type: true,
+        value: true,
+      },
     });
 
-    if (!type) {
+    if (!currentSetting?.type) {
       throw new NotFoundException(`Setting not found.`);
     }
 
+    const { type } = currentSetting;
+
     // Build update data object with only provided fields
     const updateData: any = {};
     
@@ -541,6 +622,17 @@ export class SettingService {
       data: updateData,
     });
 
+    await this.emitSettingChangedEvents([
+      {
+        settingId: updatedSetting.id,
+        slug: updatedSetting.slug,
+        type: updatedSetting.type,
+        oldValue: currentSetting.value,
+        newValue: updatedSetting.value,
+        source: 'update',
+      },
+    ]);
+
     // Garantir que o value sobrescreve o valor original
     const result = { ...updatedSetting };
     result.value = this.getValueFormattedByType(updatedSetting.type, updatedSetting.value);
@@ -549,28 +641,123 @@ export class SettingService {
 
   async updateFromSlug(slug: string, data: UpdateDTO) {
     this.clearCache();
-    const { id, type } = await this.prismaService.setting.findFirst({
+    const currentSetting = await this.prismaService.setting.findFirst({
       where: {
         slug,
       },
+      select: {
+        id: true,
+        slug: true,
+        type: true,
+        value: true,
+      },
     });
 
-    if (!id) {
+    if (!currentSetting?.id) {
       throw new NotFoundException(`Setting with slug ${slug} not found.`);
     }
 
+    const nextValue = this.setValueFormattedByType(currentSetting.type, data.value);
+
     const updatedSetting = await this.prismaService.setting.update({
-      where: { id },
+      where: { id: currentSetting.id },
       data: {
-        value: this.setValueFormattedByType(type, data.value),
+        value: nextValue,
       },
     });
 
+    await this.emitSettingChangedEvents([
+      {
+        settingId: updatedSetting.id,
+        slug: updatedSetting.slug,
+        type: updatedSetting.type,
+        oldValue: currentSetting.value,
+        newValue: updatedSetting.value,
+        source: 'updateFromSlug',
+      },
+    ]);
+
     const result = { ...updatedSetting };
     result.value = this.getValueFormattedByType(updatedSetting.type, updatedSetting.value);
     return result;
   }
 
+  private normalizeValueForComparison(value: any) {
+    if (value === undefined) {
+      return '__undefined__';
+    }
+
+    if (value === null) {
+      return null;
+    }
+
+    if (typeof value === 'string') {
+      return value.trim();
+    }
+
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+
+  private isValueDefined(value: any) {
+    if (value === undefined || value === null) {
+      return false;
+    }
+
+    if (typeof value === 'string') {
+      return value.trim().length > 0;
+    }
+
+    if (Array.isArray(value)) {
+      return value.length > 0;
+    }
+
+    return true;
+  }
+
+  private async emitSettingChangedEvents(changes: SettingChangeEventInput[]) {
+    const events = changes
+      .filter((change) => Boolean(change.slug))
+      .filter(
+        (change) =>
+          this.normalizeValueForComparison(change.oldValue) !==
+          this.normalizeValueForComparison(change.newValue),
+      )
+      .map((change) => ({
+        eventName: 'core.setting.changed',
+        sourceModule: 'core',
+        aggregateType: 'setting',
+        aggregateId: String(change.settingId ?? change.slug),
+        payload: {
+          settingId: change.settingId ?? null,
+          slug: change.slug,
+          type: change.type ?? null,
+          source: change.source,
+          hasValue: this.isValueDefined(change.newValue),
+        },
+        metadata: {
+          settingSlug: change.slug,
+          source: change.source,
+        },
+      }));
+
+    if (events.length === 0) {
+      return;
+    }
+
+    try {
+      await this.integrationApi.publishEvents(events);
+    } catch (error) {
+      this.logger.error(
+        `Failed to publish ${events.length} setting change event(s).`,
+        error instanceof Error ? error.stack : String(error),
+      );
+    }
+  }
+
   setValueFormattedByType(type: string, value: any) {
     switch (type) {
       case 'boolean':
@@ -829,23 +1016,43 @@ export class SettingService {
   async setValue(slug: string, value: string) {
     this.clearCache();
 
-    const { id } = await this.prismaService.setting.findFirst({
+    const currentSetting = await this.prismaService.setting.findFirst({
       where: {
         slug,
       },
+      select: {
+        id: true,
+        slug: true,
+        type: true,
+        value: true,
+      },
     });
 
-    if (!id) {
+    if (!currentSetting?.id) {
       throw new NotFoundException(`Setting with slug ${slug} not found.`);
     }
 
-    return this.prismaService.setting.updateMany({
+    const nextValue = this.setValueFormattedByType(currentSetting.type, value);
+    const result = await this.prismaService.setting.updateMany({
       where: {
         slug,
       },
       data: {
-        value,
+        value: nextValue,
       },
     });
+
+    await this.emitSettingChangedEvents([
+      {
+        settingId: currentSetting.id,
+        slug: currentSetting.slug,
+        type: currentSetting.type,
+        oldValue: currentSetting.value,
+        newValue: nextValue,
+        source: 'setValue',
+      },
+    ]);
+
+    return result;
   }
 }