@hed-hog/core 0.0.350 → 0.0.353

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';
@@ -75,6 +78,7 @@ import { WebhookIntegrationModule } from './webhook-integration/webhook-integrat
     forwardRef(() => McpChatModule),
     forwardRef(() => PdfModule),
     forwardRef(() => NotificationModule),
+    forwardRef(() => AccessLogModule),
   ],
   exports: [
     UserModule,
@@ -97,6 +101,7 @@ import { WebhookIntegrationModule } from './webhook-integration/webhook-integrat
     IsPinCodeWithSettingConstraint,
     PdfModule,
     NotificationModule,
+    AccessLogModule,
   ],
   providers: [
     Reflector,
@@ -110,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);
 

package/src/file/provider/provider.factory.ts

@@ -1,6 +1,7 @@
 import { JwtService } from '@nestjs/jwt';
 import { AbstractProvider } from './abstract.provider';
 import { AzureProvider } from './azure.provider';
+import { GCSProvider } from './gcs.provider';
 import { LocalProvider } from './local.provider';
 import { EnumProvider } from './provider.enum';
 import { S3Provider } from './s3.provider';
@@ -18,6 +19,8 @@ export class ProviderFactory {
         return new LocalProvider(setting, jwtService);
       case EnumProvider.AZURE:
         return new AzureProvider(setting);
+      case EnumProvider.GCS:
+        return new GCSProvider(setting);
     }
   }
 }

package/src/file/provider/s3.provider.ts

@@ -9,6 +9,8 @@ import {
 } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { BadRequestException } from '@nestjs/common';
+import { createReadStream } from 'fs';
+import { basename } from 'path';
 import { Readable } from 'stream';
 import { AbstractProvider } from './abstract.provider';
 
@@ -166,6 +168,26 @@ export class S3Provider extends AbstractProvider {
     return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
   }
 
+  async uploadFromPath(
+    destination: string,
+    filePath: string,
+    options?: { filename?: string; mimetype?: string },
+  ): Promise<any> {
+    const s3 = await this.getClient();
+    const originalName = options?.filename ?? basename(filePath);
+    const storedFilename = this.getFilename(originalName);
+    const key = [destination, storedFilename].join('/');
+    const command = new PutObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: key,
+      Body: createReadStream(filePath),
+      ContentType: options?.mimetype,
+    });
+
+    await s3.send(command);
+    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
+  }
+
   async delete(filepath: string): Promise<any> {
     const s3 = await this.getClient();
     const key = this.resolveS3Key(filepath);

package/src/mcp/mcp-audit.service.ts

@@ -1,36 +1,47 @@
-import { PrismaService } from '@hed-hog/api-prisma';
-import { Injectable, Logger } from '@nestjs/common';
-
-interface AuditRecord {
-  userId: number;
-  toolName: string;
-  input: Record<string, any>;
-  success: boolean;
-  error?: string;
-  durationMs: number;
-}
-
-@Injectable()
-export class McpAuditService {
-  private readonly logger = new Logger(McpAuditService.name);
-
-  constructor(private readonly prisma: PrismaService) {}
-
-  async record(data: AuditRecord): Promise<void> {
-    const sanitized = JSON.stringify(data.input).slice(0, 1000);
-    try {
-      await this.prisma.mcp_tool_call_log.create({
-        data: {
-          user_id: data.userId || null,
-          tool_name: data.toolName,
-          input: sanitized,
-          success: data.success,
-          error: data.error ?? null,
-          duration_ms: data.durationMs,
-        },
-      });
-    } catch (e: any) {
-      this.logger.warn(`Failed to persist MCP audit record: ${e.message}`);
-    }
-  }
-}
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { AccessLogService } from '../access-log/access-log.service';
+
+interface AuditRecord {
+  userId: number;
+  toolName: string;
+  input: Record<string, any>;
+  success: boolean;
+  error?: string;
+  durationMs: number;
+}
+
+@Injectable()
+export class McpAuditService {
+  private readonly logger = new Logger(McpAuditService.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => AccessLogService))
+    private readonly accessLogService: AccessLogService,
+  ) {}
+
+  async record(data: AuditRecord): Promise<void> {
+    const sanitized = JSON.stringify(data.input).slice(0, 1000);
+    try {
+      await this.prisma.mcp_tool_call_log.create({
+        data: {
+          user_id: data.userId || null,
+          tool_name: data.toolName,
+          input: sanitized,
+          success: data.success,
+          error: data.error ?? null,
+          duration_ms: data.durationMs,
+        },
+      });
+    } catch (e: any) {
+      this.logger.warn(`Failed to persist MCP audit record: ${e.message}`);
+    }
+
+    this.accessLogService.recordMcp({
+      userId: data.userId || undefined,
+      mcpTool: data.toolName,
+      mcpPrompt: sanitized,
+    });
+  }
+}