@hed-hog/core 0.0.356 → 0.0.359

package/src/setting/setting.service.ts

@@ -8,9 +8,13 @@ import {
     Inject,
     Injectable,
     Logger,
-    NotFoundException
+    NotFoundException,
+    OnModuleDestroy,
+    OnModuleInit,
 } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
 import * as pako from 'pako';
+import { createClient, type RedisClientType } from 'redis';
 import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
 import { CreateDTO } from './dto/create.dto';
 import { DeleteDTO } from './dto/delete.dto';
@@ -27,11 +31,34 @@ type SettingChangeEventInput = {
   source: string;
 };
 
+type SettingsVersionMessage = {
+  originInstanceId: string;
+  version: number;
+  slugs: string[];
+};
+
 @Injectable()
-export class SettingService {
+export class SettingService implements OnModuleInit, OnModuleDestroy {
 
   private readonly logger = new Logger(SettingService.name);
   private cachedSettings: Record<string, any> = {};
+  private readonly instanceId = randomUUID();
+  private readonly redisChannel = 'core:settings:version-changed';
+  private readonly redisUrl = String(process.env.REDIS_URL || '').trim();
+  private readonly settingsVersionCheckIntervalMs = Math.max(
+    1000,
+    Number(process.env.SETTINGS_VERSION_CHECK_INTERVAL_MS || 5000),
+  );
+  private localSettingsVersion = 0;
+  private lastSettingsVersionCheckAt = 0;
+  private redisPublisher: RedisClientType | null = null;
+  private redisSubscriber: RedisClientType | null = null;
+  private readonly redisErrorLogCooldownMs = Math.max(
+    1000,
+    Number(process.env.REDIS_SETTINGS_ERROR_LOG_COOLDOWN_MS || 30000),
+  );
+  private lastRedisSubscriberErrorLogAt = 0;
+  private lastRedisPublisherErrorLogAt = 0;
 
   constructor(
     @Inject(forwardRef(() => PrismaService))
@@ -44,6 +71,231 @@ export class SettingService {
     private readonly integrationApi: IntegrationDeveloperApiService,
   ) { }
 
+  async onModuleInit() {
+    await this.syncSettingsVersionFromDatabase();
+    await this.initializeRedisSync();
+  }
+
+  async onModuleDestroy() {
+    await Promise.allSettled([
+      this.safeCloseRedisClient(this.redisSubscriber),
+      this.safeCloseRedisClient(this.redisPublisher),
+    ]);
+  }
+
+  private async safeCloseRedisClient(client: RedisClientType | null) {
+    if (!client || !client.isOpen) {
+      return;
+    }
+
+    try {
+      await client.quit();
+    } catch {
+      try {
+        client.disconnect();
+      } catch {
+        // ignore shutdown errors
+      }
+    }
+  }
+
+  private logRedisClientError(kind: 'subscriber' | 'publisher', error: unknown) {
+    const now = Date.now();
+    const lastLogAt =
+      kind === 'subscriber'
+        ? this.lastRedisSubscriberErrorLogAt
+        : this.lastRedisPublisherErrorLogAt;
+
+    if (now - lastLogAt < this.redisErrorLogCooldownMs) {
+      return;
+    }
+
+    if (kind === 'subscriber') {
+      this.lastRedisSubscriberErrorLogAt = now;
+    } else {
+      this.lastRedisPublisherErrorLogAt = now;
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+    this.logger.warn(`Redis settings ${kind} error: ${message}`);
+  }
+
+  private async initializeRedisSync() {
+    if (!this.redisUrl) {
+      this.logger.log(
+        'Redis settings sync disabled because REDIS_URL is not configured.',
+      );
+      return;
+    }
+
+    try {
+      this.redisSubscriber = createClient({
+        url: this.redisUrl,
+        socket: {
+          reconnectStrategy: (retries) => Math.min(retries * 250, 5000),
+        },
+      });
+      this.redisPublisher = createClient({
+        url: this.redisUrl,
+        socket: {
+          reconnectStrategy: (retries) => Math.min(retries * 250, 5000),
+        },
+      });
+
+      this.redisSubscriber.on('error', (error) => {
+        this.logRedisClientError('subscriber', error);
+      });
+      this.redisPublisher.on('error', (error) => {
+        this.logRedisClientError('publisher', error);
+      });
+
+      await this.redisSubscriber.connect();
+      await this.redisPublisher.connect();
+      await this.redisSubscriber.subscribe(this.redisChannel, async (message) => {
+        await this.handleRedisSettingsVersionMessage(message);
+      });
+
+      this.logger.log(
+        `Redis settings sync enabled on channel ${this.redisChannel}`,
+      );
+    } catch (error) {
+      this.logger.warn(
+        `Failed to initialize Redis settings sync: ${error instanceof Error ? error.message : String(error)}`,
+      );
+
+      await Promise.allSettled([
+        this.safeCloseRedisClient(this.redisSubscriber),
+        this.safeCloseRedisClient(this.redisPublisher),
+      ]);
+
+      this.redisSubscriber = null;
+      this.redisPublisher = null;
+    }
+  }
+
+  private async handleRedisSettingsVersionMessage(message: string) {
+    let payload: SettingsVersionMessage;
+
+    try {
+      payload = JSON.parse(message) as SettingsVersionMessage;
+    } catch {
+      return;
+    }
+
+    if (!payload || payload.originInstanceId === this.instanceId) {
+      return;
+    }
+
+    if (!Number.isFinite(payload.version) || payload.version <= this.localSettingsVersion) {
+      return;
+    }
+
+    this.localSettingsVersion = payload.version;
+    this.lastSettingsVersionCheckAt = Date.now();
+    this.clearCache();
+  }
+
+  private async ensureSettingsVersionState() {
+    await this.prismaService.$executeRawUnsafe(`
+      INSERT INTO "setting_runtime_state" ("scope", "version", "updated_at")
+      VALUES ('global', 0, NOW())
+      ON CONFLICT ("scope") DO NOTHING
+    `);
+  }
+
+  private parseVersionValue(value: unknown): number {
+    if (typeof value === 'number') {
+      return value;
+    }
+
+    if (typeof value === 'bigint') {
+      return Number(value);
+    }
+
+    if (typeof value === 'string') {
+      return Number(value);
+    }
+
+    return 0;
+  }
+
+  private async getSettingsVersionFromDatabase(): Promise<number> {
+    await this.ensureSettingsVersionState();
+
+    const rows = await this.prismaService.$queryRawUnsafe<Array<{ version: unknown }>>(`
+      SELECT "version"
+      FROM "setting_runtime_state"
+      WHERE "scope" = 'global'
+      LIMIT 1
+    `);
+
+    return this.parseVersionValue(rows[0]?.version);
+  }
+
+  private async syncSettingsVersionFromDatabase() {
+    this.localSettingsVersion = await this.getSettingsVersionFromDatabase();
+    this.lastSettingsVersionCheckAt = Date.now();
+  }
+
+  private async bumpSettingsVersion(): Promise<number> {
+    await this.ensureSettingsVersionState();
+
+    const rows = await this.prismaService.$queryRawUnsafe<Array<{ version: unknown }>>(`
+      UPDATE "setting_runtime_state"
+      SET "version" = "version" + 1,
+          "updated_at" = NOW()
+      WHERE "scope" = 'global'
+      RETURNING "version"
+    `);
+
+    const nextVersion = this.parseVersionValue(rows[0]?.version);
+    this.localSettingsVersion = nextVersion;
+    this.lastSettingsVersionCheckAt = Date.now();
+    return nextVersion;
+  }
+
+  private async ensureCacheVersionFresh() {
+    const now = Date.now();
+    if (now - this.lastSettingsVersionCheckAt < this.settingsVersionCheckIntervalMs) {
+      return;
+    }
+
+    const currentVersion = await this.getSettingsVersionFromDatabase();
+    this.lastSettingsVersionCheckAt = now;
+
+    if (currentVersion > this.localSettingsVersion) {
+      this.localSettingsVersion = currentVersion;
+      this.clearCache();
+    }
+  }
+
+  private async publishSettingsVersionChange(slugs: string[]) {
+    const filteredSlugs = Array.from(new Set(slugs.filter(Boolean)));
+    if (filteredSlugs.length === 0) {
+      return;
+    }
+
+    const nextVersion = await this.bumpSettingsVersion();
+
+    if (!this.redisPublisher?.isOpen) {
+      return;
+    }
+
+    const payload: SettingsVersionMessage = {
+      originInstanceId: this.instanceId,
+      version: nextVersion,
+      slugs: filteredSlugs,
+    };
+
+    try {
+      await this.redisPublisher.publish(this.redisChannel, JSON.stringify(payload));
+    } catch (error) {
+      this.logger.warn(
+        `Failed to publish settings version change: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
   async exportSettings(includeSecrets = false): Promise<Buffer> {
     const settings = await this.prismaService.setting.findMany({
       where: {
@@ -158,6 +410,7 @@ export class SettingService {
     if (transaction.length > 0) {
       await this.prismaService.$transaction(transaction);
       await this.emitSettingChangedEvents(changedSettings);
+      await this.publishSettingsVersionChange(changedSettings.map((item) => item.slug));
     }
 
     return {
@@ -211,7 +464,14 @@ export class SettingService {
       'time-format',
       'timezone',
       'menu-width',
+      'maintenance-mode-enabled',
       'providers',
+      'oauth-facebook-enabled',
+      'oauth-github-enabled',
+      'oauth-google-enabled',
+      'oauth-microsoft-enabled',
+      'oauth-microsoft-entra-id-enabled',
+      'admin-login-page-oauth-providers',
       'disable-authentication-with-email-and-password',
       'contact-allow-company-registration',
       'operations.comment-edit-window',
@@ -311,6 +571,7 @@ export class SettingService {
 
     await this.prismaService.$transaction(transaction);
     await this.emitSettingChangedEvents(changedSettings);
+    await this.publishSettingsVersionChange(changedSettings.map((item) => item.slug));
     return { success: true };
   }
 
@@ -655,6 +916,8 @@ export class SettingService {
       },
     ]);
 
+    await this.publishSettingsVersionChange([createdSetting.slug]);
+
     return createdSetting;
   }
 
@@ -726,6 +989,8 @@ export class SettingService {
       },
     ]);
 
+    await this.publishSettingsVersionChange([updatedSetting.slug]);
+
     // Garantir que o value sobrescreve o valor original
     const result = { ...updatedSetting };
     result.value = this.getValueFormattedByType(updatedSetting.type, updatedSetting.value);
@@ -770,6 +1035,8 @@ export class SettingService {
       },
     ]);
 
+    await this.publishSettingsVersionChange([updatedSetting.slug]);
+
     const result = { ...updatedSetting };
     result.value = this.getValueFormattedByType(updatedSetting.type, updatedSetting.value);
     return result;
@@ -855,8 +1122,18 @@ export class SettingService {
     switch (type) {
       case 'boolean':
         return value === true || value === 'true' ? 'true' : 'false';
-      case 'number':
-        return Number(value).toString();
+      case 'number': {
+        if (value === undefined || value === null || String(value).trim() === '') {
+          return '';
+        }
+
+        const numericValue = Number(value);
+        if (!Number.isFinite(numericValue)) {
+          throw new BadRequestException(`Invalid numeric value for setting: ${value}`);
+        }
+
+        return numericValue.toString();
+      }
       case 'array':
       case 'json':
         return typeof value === 'string' ? value : JSON.stringify(value);
@@ -869,8 +1146,18 @@ export class SettingService {
     switch (type) {
       case 'boolean':
         return value === true || value === 'true' ? 'true' : 'false';
-      case 'number':
-        return Number(value).toString();
+      case 'number': {
+        if (value === undefined || value === null || String(value).trim() === '') {
+          return '';
+        }
+
+        const numericValue = Number(value);
+        if (!Number.isFinite(numericValue)) {
+          throw new BadRequestException(`Invalid numeric value for setting: ${value}`);
+        }
+
+        return numericValue.toString();
+      }
       case 'array':
       case 'json':
         return typeof value === 'string' ? value : JSON.stringify(value);
@@ -895,6 +1182,7 @@ export class SettingService {
       },
       select: {
         id: true,
+        slug: true,
       },
     });
 
@@ -904,13 +1192,19 @@ export class SettingService {
       );
     }
 
-    return this.prismaService.setting.deleteMany({
+    const deleted = await this.prismaService.setting.deleteMany({
       where: {
         id: {
           in: ids,
         },
       },
     });
+
+    if (deleted.count > 0) {
+      await this.publishSettingsVersionChange(existingSettings.map((item) => item.slug));
+    }
+
+    return deleted;
   }
 
   async setSettingUserValue(locale:string, user_id: number, slug: string, value: string) {
@@ -970,6 +1264,10 @@ export class SettingService {
   ): Promise<Record<string, any>> {
 
     const slugs = Array.isArray(slug) ? slug : [slug];
+    if (userId === undefined) {
+      await this.ensureCacheVersionFresh();
+    }
+
     if (
       userId === undefined &&
       this.cachedSettings &&
@@ -1142,6 +1440,8 @@ export class SettingService {
       },
     ]);
 
+    await this.publishSettingsVersionChange([currentSetting.slug]);
+
     return result;
   }
 }

package/src/user/user.controller.ts

@@ -12,12 +12,14 @@ import {
     ParseIntPipe,
     Patch,
     Post,
+    Req,
     Res,
     UploadedFile,
     UseInterceptors,
     forwardRef,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
+import { Request } from 'express';
 import { DeleteDTO } from '../dto/delete.dto';
 import { CreateWithEmailAndPasswordDTO } from './dto/create-with-email-and-password.dto';
 import { ResetPasswordDTO } from './dto/reset-password.dto';
@@ -47,9 +49,10 @@ export class UserController {
   async openPublicAvatar(
     @Param('fileId', ParseIntPipe) fileId: number,
     @Locale() locale: string,
+    @Req() req: Request,
     @Res() res,
   ) {
-    return this.userService.openPublicAvatar(locale, fileId, res);
+    return this.userService.openPublicAvatar(locale, fileId, req.headers['if-none-match'] as string | undefined, res);
   }
 
   @Post()

package/src/user/user.service.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'crypto';
 import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
@@ -13,6 +14,7 @@ import { DeleteDTO } from '../dto/delete.dto';
 import { FileService } from '../file/file.service';
 import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
 import { SecurityService } from '../security/security.service';
+import { SettingService } from '../setting/setting.service';
 import { USER_AVATAR_UPLOAD_DESTINATION } from './constants/user.constants';
 import { CreateWithEmailAndPasswordDTO } from './dto/create-with-email-and-password.dto';
 import { ResetPasswordDTO } from './dto/reset-password.dto';
@@ -27,6 +29,7 @@ const CREDENTIAL_TYPE = {
   PASSWORD: 'password',
 } as const;
 
+const USER_AVATAR_CACHE_MAX_AGE_SETTING = 'user-avatar-cache-max-age';
 const DEFAULT_ROLE_SLUG = 'user';
 const DEFAULT_LOCALE = 'en';
 const DAYS_IN_MS = 24 * 60 * 60 * 1000;
@@ -68,6 +71,8 @@ export class UserService {
     private readonly file: FileService,
     @Inject(forwardRef(() => IntegrationDeveloperApiService))
     private readonly integrationApi: IntegrationDeveloperApiService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
   ) { }
 
   // ==========================================
@@ -319,7 +324,7 @@ export class UserService {
     };
   }
 
-  async openPublicAvatar(locale: string, fileId: number, res: any) {
+  async openPublicAvatar(locale: string, fileId: number, ifNoneMatch: string | undefined, res: any) {
     const userWithAvatar = await this.prismaService.user.findFirst({
       where: {
         photo_id: fileId,
@@ -337,10 +342,23 @@ export class UserService {
 
     const { file, buffer } = await this.file.getBuffer(fileId);
 
+    const etag = `"${createHash('md5').update(buffer).digest('hex')}"`;
+
+    if (ifNoneMatch === etag) {
+      res.status(304).send();
+      return;
+    }
+
+    const settings = await this.settingService.getSettingValues(
+      USER_AVATAR_CACHE_MAX_AGE_SETTING,
+    );
+    const maxAge = Number(settings[USER_AVATAR_CACHE_MAX_AGE_SETTING] ?? 3600);
+
     res.set({
       'Content-Type': file.file_mimetype.name,
       'Content-Length': buffer.length,
-      'Cache-Control': 'public, max-age=3600',
+      'Cache-Control': `public, max-age=${maxAge}`,
+      'ETag': etag,
     });
 
     res.send(buffer);

package/src/webhook-integration/dto/webhook-action.dto.ts

@@ -1,6 +1,6 @@
 import { Transform } from 'class-transformer';
 import { PartialType } from '@nestjs/mapped-types';
-import { IsIn, IsInt, IsOptional, IsString } from 'class-validator';
+import { IsIn, IsInt, IsObject, IsOptional, IsString } from 'class-validator';
 
 const toNullableInteger = ({ value }: { value: unknown }) => {
   if (value === undefined || value === null || value === '') {
@@ -19,8 +19,19 @@ const toOptionalTrimmedString = ({ value }: { value: unknown }) => {
 };
 
 export class CreateWebhookActionDTO {
-  @IsIn(['email', 'whatsapp_evolution'])
-  type: 'email' | 'whatsapp_evolution';
+  @IsIn([
+    'email',
+    'whatsapp_evolution',
+    'http_request',
+    'internal_api',
+    'app_command',
+  ])
+  type:
+    | 'email'
+    | 'whatsapp_evolution'
+    | 'http_request'
+    | 'internal_api'
+    | 'app_command';
 
   @IsOptional()
   @Transform(toOptionalTrimmedString)
@@ -39,7 +50,7 @@ export class CreateWebhookActionDTO {
   @IsOptional()
   @Transform(toNullableInteger)
   @IsInt()
-  mail_profile_id?: number;
+  integration_profile_id?: number;
 
   @IsOptional()
   @Transform(toNullableInteger)
@@ -89,6 +100,76 @@ export class CreateWebhookActionDTO {
   @Transform(toOptionalTrimmedString)
   @IsString()
   whatsapp_token?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  http_url?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  http_method?: string;
+
+  @IsOptional()
+  @IsObject()
+  http_headers?: Record<string, string>;
+
+  @IsOptional()
+  @IsObject()
+  http_query?: Record<string, string>;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  http_body?: string;
+
+  @IsOptional()
+  @Transform(toNullableInteger)
+  @IsInt()
+  http_timeout_ms?: number;
+
+  @IsOptional()
+  @Transform(toNullableInteger)
+  @IsInt()
+  http_retry_count?: number;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  internal_api_path?: string;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  internal_api_method?: string;
+
+  @IsOptional()
+  @IsObject()
+  internal_api_query?: Record<string, unknown>;
+
+  @IsOptional()
+  @IsObject()
+  internal_api_body?: Record<string, unknown>;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  internal_api_token?: string;
+
+  @IsOptional()
+  @Transform(toNullableInteger)
+  @IsInt()
+  internal_api_user_id?: number;
+
+  @IsOptional()
+  @Transform(toOptionalTrimmedString)
+  @IsString()
+  app_command_slug?: string;
+
+  @IsOptional()
+  @IsObject()
+  app_command_params?: Record<string, unknown>;
 }
 
 export class UpdateWebhookActionDTO extends PartialType(

package/src/webhook-integration/webhook-command.registry.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@nestjs/common';
+
+export interface WebhookCommand {
+  slug: string;
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  handler: (
+    params: Record<string, unknown>,
+    context?: Record<string, unknown>,
+  ) => Promise<unknown>;
+}
+
+@Injectable()
+export class WebhookCommandRegistry {
+  private readonly commands = new Map<string, WebhookCommand>();
+
+  register(command: WebhookCommand): void {
+    this.commands.set(command.slug, command);
+  }
+
+  find(slug: string): WebhookCommand | undefined {
+    return this.commands.get(slug);
+  }
+
+  list(): WebhookCommand[] {
+    return Array.from(this.commands.values());
+  }
+
+  async dispatch(
+    slug: string,
+    params: Record<string, unknown>,
+    context?: Record<string, unknown>,
+  ): Promise<unknown> {
+    const command = this.find(slug);
+    if (!command) {
+      throw new Error(`Unknown app_command slug: ${slug}`);
+    }
+
+    return command.handler(params, context);
+  }
+}

package/src/webhook-integration/webhook-integration.controller.ts

@@ -31,6 +31,26 @@ export class WebhookIntegrationController {
     return this.service.list(paginationParams);
   }
 
+  @Get('user-tokens')
+  listUserTokens(@Query('userId', ParseIntPipe) userId: number) {
+    return this.service.listUserApiTokens(userId);
+  }
+
+  @Post('user-tokens')
+  createUserToken(@Body() data: { userId: number; name: string }) {
+    return this.service.createUserApiToken(data.userId, data.name);
+  }
+
+  @Get('internal-routes')
+  listInternalRoutes() {
+    return this.service.listInternalRoutes();
+  }
+
+  @Get('app-commands')
+  listAppCommands() {
+    return this.service.listAppCommands();
+  }
+
   @Get(':id')
   get(@Param('id', ParseIntPipe) id: number) {
     return this.service.get(id);