@hed-hog/core 0.0.349 → 0.0.351

package/src/access-log/access-log.module.ts

@@ -0,0 +1,16 @@
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { AccessLogController } from './access-log.controller';
+import { AccessLogService } from './access-log.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+  controllers: [AccessLogController],
+  providers: [AccessLogService],
+  exports: [AccessLogService],
+})
+export class AccessLogModule {}

package/src/access-log/access-log.service.ts

@@ -0,0 +1,129 @@
+import { PageOrderDirection, PaginationService } from '@hed-hog/api-pagination';
+import { Prisma, PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+
+interface RecordHttpData {
+  userId?: number;
+  ip?: string;
+  userAgent?: string;
+  method: string;
+  path: string;
+}
+
+interface RecordMcpData {
+  userId?: number;
+  mcpTool: string;
+  mcpPrompt?: string;
+}
+
+type AccessLogListParams = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  sortField?: string;
+  sortOrder?: PageOrderDirection;
+  fields?: string;
+  userId?: number;
+  userSearch?: string;
+  createdAtFrom?: string;
+  createdAtTo?: string;
+  type?: 'http' | 'mcp' | 'all';
+};
+
+@Injectable()
+export class AccessLogService {
+  private readonly logger = new Logger(AccessLogService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly pagination: PaginationService,
+  ) {}
+
+  recordHttp(data: RecordHttpData): void {
+    this.prisma.access_log
+      .create({
+        data: {
+          user_id: data.userId ?? null,
+          ip: data.ip ?? null,
+          user_agent: data.userAgent ?? null,
+          method: data.method,
+          path: data.path,
+        },
+      })
+      .catch((e) => this.logger.warn(`Failed to persist HTTP access log: ${e.message}`));
+  }
+
+  recordMcp(data: RecordMcpData): void {
+    this.prisma.access_log
+      .create({
+        data: {
+          user_id: data.userId ?? null,
+          mcp_tool: data.mcpTool,
+          mcp_prompt: data.mcpPrompt ?? null,
+        },
+      })
+      .catch((e) => this.logger.warn(`Failed to persist MCP access log: ${e.message}`));
+  }
+
+  async list(params: AccessLogListParams) {
+    const where: Prisma.access_logWhereInput = {};
+
+    if (params.userId) {
+      where.user_id = params.userId;
+    }
+
+    if (params.userSearch) {
+      where.user = {
+        OR: [
+          { name: { contains: params.userSearch, mode: 'insensitive' } },
+        ],
+      };
+    }
+
+    if (params.createdAtFrom || params.createdAtTo) {
+      where.created_at = {};
+      if (params.createdAtFrom) {
+        where.created_at.gte = new Date(params.createdAtFrom);
+      }
+      if (params.createdAtTo) {
+        const to = new Date(params.createdAtTo);
+        to.setHours(23, 59, 59, 999);
+        where.created_at.lte = to;
+      }
+    }
+
+    if (params.type === 'http') {
+      where.method = { not: null };
+    } else if (params.type === 'mcp') {
+      where.mcp_tool = { not: null };
+    }
+
+    return this.pagination.paginate(this.prisma.access_log, {
+      ...params,
+      fields: params.fields ?? '',
+    }, {
+      where,
+      orderBy: { created_at: 'desc' },
+      include: {
+        user: { select: { id: true, name: true, photo_id: true } },
+      },
+    });
+  }
+
+  async clearOld(retentionDays: number, batchLimit: number): Promise<void> {
+    await this.prisma.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM access_log
+        WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM access_log al
+      USING del
+      WHERE al.id = del.id
+    `;
+  }
+}

package/src/access-log/dto/query-access-log.dto.ts

@@ -0,0 +1,23 @@
+import { IsIn, IsNumberString, IsOptional, IsString } from 'class-validator';
+
+export class QueryAccessLogDto {
+  @IsOptional()
+  @IsNumberString()
+  userId?: string;
+
+  @IsOptional()
+  @IsString()
+  userSearch?: string;
+
+  @IsOptional()
+  @IsString()
+  createdAtFrom?: string;
+
+  @IsOptional()
+  @IsString()
+  createdAtTo?: string;
+
+  @IsOptional()
+  @IsIn(['http', 'mcp', 'all'])
+  type?: 'http' | 'mcp' | 'all';
+}

package/src/auth/auth.service.ts

@@ -82,8 +82,6 @@ export class AuthService {
 
   async requiresMfaForLogin(locale: string, email: string, user: any) {
 
-    console.log('MFA required, setting up email MFA');
-
     const settings = await this.setting.getSettingValues([
       'require-mfa',
       'require-email-verification',
@@ -387,16 +385,11 @@ export class AuthService {
 
     if (!user) throw new BadRequestException(getLocaleText('accessDenied', locale, 'Access denied.'));
 
-    console.debug({ user });
-
     const credentials = (user as unknown as User).user_credential?.filter((c) => c.type === 'password') || [];
 
-    console.debug({ credentials });
-
     const identifier = user.user_identifier?.find((i) => i.type === 'email' && i.value === email);
 
     if (!(await this.security.validatePassword(locale, credentials, password))) {
-      console.debug('Invalid password');
       throw new BadRequestException(getLocaleText('accessDenied', locale, 'Access denied.'));
     }
 

package/src/challenge/challenge.service.ts

@@ -376,8 +376,6 @@ export class ChallengeService {
 
   async sendMfaCodeToMultipleEmails(locale: string, userId: number, emails: string[]) {
 
-    console.log('Sending MFA codes to multiple emails:', emails);
-
     if (!emails || emails.length === 0) {
       return { success: true };
     }

package/src/core/system.module.ts

@@ -13,5 +13,6 @@ import { SystemService } from './system.service';
   ],
   controllers: [SystemController],
   providers: [SystemService],
+  exports: [SystemService],
 })
 export class SystemModule { }

package/src/core.module.ts

@@ -1,5 +1,8 @@
 import { LogInterceptor } from '@hed-hog/api';
 import { LocaleModule } from '@hed-hog/api-locale';
+import { AccessLogInterceptor } from './access-log/access-log.interceptor';
+import { AccessLogModule } from './access-log/access-log.module';
+import { AccessLogService } from './access-log/access-log.service';
 import { MailModule as MailSendModule } from '@hed-hog/api-mail';
 import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule, PrismaService } from '@hed-hog/api-prisma';
@@ -37,6 +40,7 @@ import { IsEmailWithSettingsConstraint } from './validators/is-email-with-settin
 import { IsPinCodeWithSettingConstraint } from './validators/is-pin-code-with-setting.validator';
 import { IsStrongPasswordWithSettingsConstraint } from './validators/is-strong-password-with-settings.validator';
 import { ValidatorServiceLocator } from './validators/service-locator';
+import { NotificationModule } from './notification/notification.module';
 import { WebhookIntegrationModule } from './webhook-integration/webhook-integration.module';
 
 @Global()
@@ -73,6 +77,8 @@ import { WebhookIntegrationModule } from './webhook-integration/webhook-integrat
     forwardRef(() => McpModule),
     forwardRef(() => McpChatModule),
     forwardRef(() => PdfModule),
+    forwardRef(() => NotificationModule),
+    forwardRef(() => AccessLogModule),
   ],
   exports: [
     UserModule,
@@ -94,6 +100,8 @@ import { WebhookIntegrationModule } from './webhook-integration/webhook-integrat
     IsEmailWithSettingsConstraint,
     IsPinCodeWithSettingConstraint,
     PdfModule,
+    NotificationModule,
+    AccessLogModule,
   ],
   providers: [
     Reflector,
@@ -107,6 +115,13 @@ import { WebhookIntegrationModule } from './webhook-integration/webhook-integrat
       },
       inject: [Reflector, PrismaService],
     },
+    {
+      provide: APP_INTERCEPTOR,
+      useFactory: (accessLogService: AccessLogService) => {
+        return new AccessLogInterceptor(accessLogService);
+      },
+      inject: [AccessLogService],
+    },
   ]
 })
 export class CoreModule implements NestModule, OnModuleInit {

package/src/dashboard/dashboard.module.ts

@@ -23,6 +23,9 @@ import { DashboardCrudModule } from './dashboard/dashboard.module';
   ],
   controllers: [],
   providers: [],
-  exports: [],
+  exports: [
+    forwardRef(() => DashboardCrudModule),
+    forwardRef(() => DashboardItemModule),
+  ],
 })
 export class DashboardModule {}

package/src/file/file.controller.ts

@@ -2,19 +2,19 @@ import { Public, Role } from '@hed-hog/api';
 import { getLocaleText, Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
-    Body,
-    Controller,
-    Delete,
-    forwardRef,
-    Get,
-    Inject,
-    Param,
-    ParseIntPipe,
-    Post,
-    Put,
-    Res,
-    UploadedFile,
-    UseInterceptors,
+  Body,
+  Controller,
+  Delete,
+  forwardRef,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Post,
+  Put,
+  Res,
+  UploadedFile,
+  UseInterceptors,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
 import { Response } from 'express';
@@ -54,7 +54,7 @@ export class FileController {
 
   @Put('download/:id')
   async getTempURL(@Param('id', ParseIntPipe) id) {
-    console.log('Generating temp URL for file ID:', id);
+    
     return {
       url: await this.fileService.tempURL(
         (await this.fileService.get(id)).path,

package/src/file/file.service.ts

@@ -10,6 +10,9 @@ import {
     OnModuleInit
 } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
+import { createWriteStream, promises as fs } from 'fs';
+import { basename, dirname } from 'path';
+import { pipeline } from 'stream/promises';
 import { SettingService } from '../setting/setting.service';
 import { DeleteDTO } from './dto/delete.dto';
 import { AbstractProvider } from './provider/abstract.provider';
@@ -235,6 +238,113 @@ export class FileService implements OnModuleInit {
     return settings['storage']; 
   }
 
+  private getProviderPath(storage: string, filepath: string) {
+    if (storage === EnumProvider.LOCAL) {
+      return filepath;
+    }
+
+    try {
+      return new URL(filepath).pathname;
+    } catch {
+      return filepath;
+    }
+  }
+
+  private mapStorageNotFoundError(error: any, fileId: number) {
+    const missingInStorage =
+      error?.name === 'NoSuchKey' ||
+      error?.Code === 'NoSuchKey' ||
+      error?.$metadata?.httpStatusCode === 404;
+
+    if (missingInStorage) {
+      throw new NotFoundException(`File not found in storage: ${fileId}`);
+    }
+
+    throw error;
+  }
+
+  async openReadStreamById(fileId: number) {
+    if (!fileId) {
+      throw new BadRequestException(`No file ID provided`);
+    }
+
+    const file = await this.prismaService.file.findUnique({
+      where: {
+        id: fileId,
+      },
+      include: {
+        file_mimetype: true,
+      },
+    });
+
+    if (!file) {
+      throw new NotFoundException(`File not found: ${fileId}`);
+    }
+
+    const storage = await this.getStorage();
+    const provider = await this.getProvider();
+    const providerPath = this.getProviderPath(storage, file.path);
+
+    let metadata: any;
+    try {
+      metadata = await provider.metaData(providerPath);
+    } catch {
+      metadata = undefined;
+    }
+
+    try {
+      const stream = await provider.readStream(providerPath);
+      return {
+        file,
+        stream,
+        size: file.size ?? this.getFileSizeFromMetadata(metadata),
+      };
+    } catch (error) {
+      this.mapStorageNotFoundError(error, fileId);
+    }
+  }
+
+  async downloadToPath(
+    fileId: number,
+    destinationPath: string,
+    options?: { maxBytes?: number },
+  ) {
+    if (!destinationPath) {
+      throw new BadRequestException(`No destination path provided`);
+    }
+
+    const { file, stream, size } = await this.openReadStreamById(fileId);
+
+    if (options?.maxBytes && size && size > options.maxBytes) {
+      throw new BadRequestException(
+        `File too large for streaming download: ${size} bytes (max ${options.maxBytes})`,
+      );
+    }
+
+    await fs.mkdir(dirname(destinationPath), { recursive: true });
+
+    try {
+      await pipeline(stream, createWriteStream(destinationPath));
+      const stats = await fs.stat(destinationPath);
+
+      if (options?.maxBytes && stats.size > options.maxBytes) {
+        await fs.unlink(destinationPath).catch(() => undefined);
+        throw new BadRequestException(
+          `File too large for streaming download: ${stats.size} bytes (max ${options.maxBytes})`,
+        );
+      }
+
+      return {
+        file,
+        path: destinationPath,
+        size: stats.size,
+      };
+    } catch (error) {
+      await fs.unlink(destinationPath).catch(() => undefined);
+      throw error;
+    }
+  }
+
   async getBuffer(fileId: number) {
 
     if (!fileId) {
@@ -258,8 +368,7 @@ export class FileService implements OnModuleInit {
 
     const provider = await this.getProvider();
 
-    const providerPath =
-      storage === EnumProvider.LOCAL ? file.path : new URL(file.path).pathname;
+    const providerPath = this.getProviderPath(storage, file.path);
 
     let providerBuffer: Buffer;
     try {
@@ -341,6 +450,89 @@ export class FileService implements OnModuleInit {
     return file;
   }
 
+  async uploadFromPath(
+    destination: string,
+    filePath: string,
+    metadata?: {
+      originalname?: string;
+      filename?: string;
+      mimetype?: string;
+      size?: number;
+      encoding?: string;
+    },
+  ) {
+    if (!filePath) {
+      throw new BadRequestException(`No file path provided`);
+    }
+
+    if (!destination) {
+      throw new BadRequestException(`No destination provided`);
+    }
+
+    const stats = await fs.stat(filePath).catch(() => null);
+    if (!stats || !stats.isFile()) {
+      throw new NotFoundException(`File path not found: ${filePath}`);
+    }
+
+    const size = metadata?.size ?? stats.size;
+    const mimetype = metadata?.mimetype ?? 'application/octet-stream';
+    const originalname = this.normalizeUploadedFilename(
+      metadata?.originalname ?? metadata?.filename ?? basename(filePath),
+    );
+
+    if (!(await this.acceptMimetypes(mimetype))) {
+      throw new BadRequestException(`Invalid file type: ${mimetype}`);
+    }
+
+    if (!(await this.maxFileSize(size))) {
+      throw new BadRequestException(`File too large: ${size} bytes`);
+    }
+
+    const provider = await this.getProvider();
+    const providerWithPathUpload = provider as AbstractProvider & {
+      uploadFromPath?: (
+        destination: string,
+        filePath: string,
+        options?: { filename?: string; mimetype?: string },
+      ) => Promise<string>;
+    };
+
+    let url: string;
+    if (typeof providerWithPathUpload.uploadFromPath === 'function') {
+      url = await providerWithPathUpload.uploadFromPath(destination, filePath, {
+        filename: originalname,
+        mimetype,
+      });
+    } else {
+      // Fallback explícito para providers legados sem suporte nativo por path.
+      const buffer = await fs.readFile(filePath);
+      url = await provider.upload(destination, {
+        fieldname: 'file',
+        originalname,
+        encoding: metadata?.encoding ?? '7bit',
+        mimetype,
+        size,
+        destination: '',
+        filename: originalname,
+        path: filePath,
+        buffer,
+      });
+    }
+
+    const file = await this.prismaService.file.create({
+      data: {
+        filename: originalname,
+        path: url,
+        provider_id: this.providerId,
+        location: destination,
+        mimetype_id: await this.getMimeType(mimetype),
+        size,
+      },
+    });
+
+    return file;
+  }
+
   async delete(locale:string,{ ids }: DeleteDTO) {
     const files = await this.prismaService.file.findMany({
       where: {
@@ -482,9 +674,11 @@ export class FileService implements OnModuleInit {
       );
     }
 
+    const storage = await this.getStorage();
     const provider = await this.getProvider();
-    const metadata = await provider.metaData(file.path);
-    const stream = await provider.readStream(file.path);
+    const providerPath = this.getProviderPath(storage, file.path);
+    const metadata = await provider.metaData(providerPath);
+    const stream = await provider.readStream(providerPath);
     const size = this.getFileSizeFromMetadata(metadata);
 
     return {

package/src/file/provider/abstract.provider.ts

@@ -9,6 +9,11 @@ interface IProvider {
     mimetype?: string,
   ): Promise<any>;
   upload(destination: string, file: MulterFile): Promise<any>;
+  uploadFromPath(
+    destination: string,
+    filePath: string,
+    options?: { filename?: string; mimetype?: string },
+  ): Promise<any>;
   readStream(filepath: string): Promise<any>;
   delete(filepath: string): Promise<any>;
   metaData(filepath: string): Promise<any>;
@@ -25,6 +30,11 @@ export abstract class AbstractProvider implements IProvider {
     mimetype?: string,
   ): Promise<any>;
   abstract upload(destination: string, file: MulterFile): Promise<any>;
+  abstract uploadFromPath(
+    destination: string,
+    filePath: string,
+    options?: { filename?: string; mimetype?: string },
+  ): Promise<any>;
   abstract readStream(filepath: string): Promise<any>;
   abstract delete(filepath: string): Promise<any>;
   abstract metaData(filepath: string): Promise<any>;

package/src/file/provider/azure.provider.ts

@@ -5,6 +5,7 @@ import {
   StorageSharedKeyCredential,
 } from '@azure/storage-blob';
 import { BadRequestException } from '@nestjs/common';
+import { basename } from 'path';
 import { AbstractProvider } from './abstract.provider';
 
 export class AzureProvider extends AbstractProvider {
@@ -92,6 +93,29 @@ export class AzureProvider extends AbstractProvider {
     return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
   }
 
+  async uploadFromPath(
+    destination: string,
+    filePath: string,
+    options?: { filename?: string; mimetype?: string },
+  ): Promise<any> {
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const filepath = [destination, this.getFilename(options?.filename ?? basename(filePath))].join(
+      '/',
+    );
+    const blobClient = containerClient.getBlockBlobClient(filepath);
+
+    await blobClient.uploadFile(filePath, {
+      blobHTTPHeaders: options?.mimetype
+        ? { blobContentType: options.mimetype }
+        : undefined,
+    });
+
+    return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
+  }
+
   async delete(filepath: string): Promise<any> {
     const url = new URL(filepath);
 

package/src/file/provider/gcs.provider.ts

@@ -1,5 +1,6 @@
 import { Storage } from '@google-cloud/storage';
 import { BadRequestException } from '@nestjs/common';
+import { basename } from 'path';
 import { AbstractProvider } from './abstract.provider';
 
 export class GCSProvider extends AbstractProvider {
@@ -67,6 +68,25 @@ export class GCSProvider extends AbstractProvider {
       contentType: file.mimetype,
     });
   }
+
+  async uploadFromPath(
+    destination: string,
+    filePath: string,
+    options?: { filename?: string; mimetype?: string },
+  ): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const objectPath = [destination.replace(/\/$/, ''), this.getFilename(options?.filename ?? basename(filePath))]
+      .filter(Boolean)
+      .join('/');
+
+    await bucket.upload(filePath, {
+      destination: objectPath,
+      contentType: options?.mimetype,
+    });
+
+    return objectPath;
+  }
   async readStream(filepath: string): Promise<any> {
     const storage = await this.getClient();
     const bucket = storage.bucket(this.setting['storage-gcs-bucket']);

package/src/file/provider/local.provider.ts

@@ -1,9 +1,9 @@
 import { BadRequestException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { createReadStream, existsSync, promises as fs } from 'fs';
-import { mkdir, unlink, writeFile } from 'fs/promises';
+import { copyFile, mkdir, stat, unlink, writeFile } from 'fs/promises';
 import * as path from 'path';
-import { join, sep } from 'path';
+import { basename, join, sep } from 'path';
 import { Stream } from 'stream';
 import { AbstractProvider } from './abstract.provider';
 
@@ -99,6 +99,34 @@ export class LocalProvider extends AbstractProvider {
     return filePath;
   }
 
+  async uploadFromPath(
+    destination: string,
+    filePath: string,
+    options?: { filename?: string; mimetype?: string },
+  ): Promise<any> {
+    const sourcePath = this.resolveFilepath(filePath);
+    if (!existsSync(sourcePath)) {
+      throw new BadRequestException(`File not found: ${sourcePath}`);
+    }
+
+    const sourceStats = await stat(sourcePath);
+    if (!sourceStats.isFile()) {
+      throw new BadRequestException(`Invalid file path: ${sourcePath}`);
+    }
+
+    const storagePath = join(this.setting['storage-local-path'], destination);
+
+    if (!existsSync(storagePath)) {
+      await this.createFolderRecursive(storagePath);
+    }
+
+    const targetFilename = this.getFilename(options?.filename ?? basename(sourcePath));
+    const targetPath = join(storagePath, targetFilename);
+    await copyFile(sourcePath, targetPath);
+
+    return targetPath;
+  }
+
   async delete(filepath: string): Promise<any> {
     const fullPath = this.resolveFilepath(filepath);