@hed-hog/core 0.0.354 → 0.0.356

package/src/file/file.service.ts

@@ -13,6 +13,11 @@ import { JwtService } from '@nestjs/jwt';
 import { createWriteStream, promises as fs } from 'fs';
 import { basename, dirname } from 'path';
 import { pipeline } from 'stream/promises';
+import {
+  buildStorageConfigFromIntegration,
+  resolveFileProviderSlug,
+  resolveStorageEnumProvider,
+} from '../integration-profile/integration-profile.utils';
 import { SettingService } from '../setting/setting.service';
 import { DeleteDTO } from './dto/delete.dto';
 import { AbstractProvider } from './provider/abstract.provider';
@@ -53,53 +58,56 @@ export class FileService implements OnModuleInit {
   ) { }
 
   async onModuleInit() {
-    await this.getProvider();
+    try {
+      await this.getProvider();
+    } catch {
+      // No storage profile configured yet — server starts normally, uploads will
+      // fail until a profile is selected in Settings → File Storage.
+    }
   }
 
   async getProvider(): Promise<AbstractProvider> {
-    const settings = await this.settingService.getSettingValues([
-      'storage',
-      'storage-local-path',
-      'storage-s3-key',
-      'storage-s3-secret',
-      'storage-s3-region',
-      'storage-s3-bucket',
-      'storage-max-size',
-      'storage-accept-mimetype',
-      'storage-abs-account',
-      'storage-abs-key',
-      'storage-abs-container',
-      'storage-gcs-keyfile',
-    ]);
-
-    if (!settings['storage']) {
+    const settings = await this.settingService.getSettingValues(['file-storage-profile-id']);
+    const profileId = Number(settings['file-storage-profile-id']);
+
+    if (!profileId) {
+      throw new BadRequestException('No file storage profile configured. Set a storage profile in the File Storage settings.');
+    }
+
+    const profile = await this.prismaService.integration_profile.findUnique({
+      where: { id: profileId },
+      include: {
+        integration_type: { select: { slug: true } },
+        integration_provider: { select: { slug: true } },
+      },
+    });
+
+    if (!profile) {
+      throw new NotFoundException(`Storage profile with id ${profileId} not found.`);
+    }
+
+    if (profile.integration_type.slug !== 'storage') {
       throw new BadRequestException(
-        `You must set the storage provider in the setting.`,
+        `Integration profile with id ${profileId} is not a storage profile.`,
       );
     }
 
-    const providerName = settings['storage'];
-    const provider = ProviderFactory.create(
-      providerName as EnumProvider,
-      settings,
-      this.jwtService,
-    );
+    const providerSlug = profile.integration_provider.slug;
+    const config = buildStorageConfigFromIntegration(providerSlug, profile.config);
+    const enumProvider = resolveStorageEnumProvider(providerSlug);
+    const fileProviderSlug = resolveFileProviderSlug(providerSlug);
 
     const providerData = await this.prismaService.file_provider.findFirst({
-      where: {
-        slug: providerName,
-      },
-      select: {
-        id: true,
-      },
+      where: { slug: fileProviderSlug },
+      select: { id: true },
     });
 
     if (!providerData) {
-      throw new BadRequestException(`Provider ${providerName} not found.`);
+      throw new BadRequestException(`Provider ${fileProviderSlug} not found.`);
     }
 
     this.providerId = providerData.id;
-    return provider;
+    return ProviderFactory.create(enumProvider, config, this.jwtService);
   }
 
   async getMimeType(mimetype: string) {
@@ -130,58 +138,22 @@ export class FileService implements OnModuleInit {
   }
 
   async acceptMimetypes(mimetype: string) {
-
     if (!mimetype) {
       throw new BadRequestException(`No mimetype provided`);
     }
 
-    await this.getProvider();
-
-    const settings = await this.settingService.getSettingValues([
-      'storage',
-      'storage-local-path',
-      'storage-s3-key',
-      'storage-s3-secret',
-      'storage-s3-region',
-      'storage-s3-bucket',
-      'storage-max-size',
-      'storage-accept-mimetype',
-      'storage-abs-account',
-      'storage-abs-key',
-      'storage-abs-container',
-      'storage-gcs-keyfile',
-    ]);
-
+    const settings = await this.settingService.getSettingValues(['storage-accept-mimetype']);
     const acceptMimetypes = settings['storage-accept-mimetype'];
     return acceptMimetypes.indexOf(mimetype) !== -1;
   }
 
   async maxFileSize(size: number) {
-
     if (!size) {
       throw new BadRequestException(`No size provided`);
     }
 
-      await this.getProvider();
-    
-      const settings = await this.settingService.getSettingValues([
-      'storage',
-      'storage-local-path',
-      'storage-s3-key',
-      'storage-s3-secret',
-      'storage-s3-region',
-      'storage-s3-bucket',
-      'storage-max-size',
-      'storage-accept-mimetype',
-      'storage-abs-account',
-      'storage-abs-key',
-      'storage-abs-container',
-      'storage-gcs-keyfile',
-    ]);
-
-    const maxSize = settings['storage-max-size'];
-
-    return size <= Number(maxSize);
+    const settings = await this.settingService.getSettingValues(['storage-max-size']);
+    return size <= Number(settings['storage-max-size']);
   }
 
   async uploadFromString(
@@ -230,12 +202,24 @@ export class FileService implements OnModuleInit {
     return file;
   }
 
-  async getStorage() {
-    const settings = await this.settingService.getSettingValues([
-      'storage',
-    ]);
+  async getStorage(): Promise<string> {
+    const settings = await this.settingService.getSettingValues(['file-storage-profile-id']);
+    const profileId = Number(settings['file-storage-profile-id']);
+
+    if (!profileId) {
+      return EnumProvider.LOCAL;
+    }
+
+    const profile = await this.prismaService.integration_profile.findUnique({
+      where: { id: profileId },
+      include: { integration_provider: { select: { slug: true } } },
+    });
+
+    if (!profile) {
+      return EnumProvider.LOCAL;
+    }
 
-    return settings['storage']; 
+    return resolveStorageEnumProvider(profile.integration_provider.slug);
   }
 
   private getProviderPath(storage: string, filepath: string) {

package/src/file/provider/provider.enum.ts

@@ -3,4 +3,5 @@ export enum EnumProvider {
   LOCAL = 'local',
   AZURE = 'abs',
   GCS = 'gcs',
+  SPACES = 'spaces',
 }

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

@@ -5,6 +5,7 @@ import { GCSProvider } from './gcs.provider';
 import { LocalProvider } from './local.provider';
 import { EnumProvider } from './provider.enum';
 import { S3Provider } from './s3.provider';
+import { SpacesProvider } from './spaces.provider';
 
 export class ProviderFactory {
   static create(
@@ -21,6 +22,8 @@ export class ProviderFactory {
         return new AzureProvider(setting);
       case EnumProvider.GCS:
         return new GCSProvider(setting);
+      case EnumProvider.SPACES:
+        return new SpacesProvider(setting);
     }
   }
 }

package/src/file/provider/spaces.provider.ts

@@ -0,0 +1,261 @@
+import {
+    DeleteObjectCommand,
+    GetObjectCommand,
+    HeadBucketCommand,
+    HeadObjectCommand,
+    PutObjectCommand,
+    S3,
+    S3Client,
+} 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';
+
+export class SpacesProvider extends AbstractProvider {
+  private S3: S3 | undefined;
+  private S3Client: S3Client | undefined;
+
+  constructor(private setting: Record<string, string>) {
+    super();
+    this.initValidation();
+  }
+
+  private get endpoint() {
+    return `https://${this.setting['storage-spaces-region']}.digitaloceanspaces.com`;
+  }
+
+  private get bucketUrl() {
+    const cdn = this.setting['storage-spaces-cdn'];
+    if (cdn) {
+      return cdn.replace(/\/$/, '');
+    }
+    return `https://${this.setting['storage-spaces-bucket']}.${this.setting['storage-spaces-region']}.digitaloceanspaces.com`;
+  }
+
+  private resolveKey(filepath: string): string {
+    if (!filepath) {
+      throw new Error('Invalid filepath for DigitalOcean Spaces');
+    }
+
+    try {
+      const url = new URL(filepath);
+      const key = url.pathname.split('/').filter(Boolean).join('/');
+      if (!key) {
+        throw new Error(`Invalid filepath "${filepath}" for DigitalOcean Spaces`);
+      }
+      return key;
+    } catch {
+      const key = filepath.split('/').filter(Boolean).join('/');
+      if (!key) {
+        throw new Error(`Invalid filepath "${filepath}" for DigitalOcean Spaces`);
+      }
+      return key;
+    }
+  }
+
+  async initValidation() {
+    if (!this.setting['storage-spaces-key']) {
+      throw new BadRequestException(
+        `You must set the storage-spaces-key in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-spaces-secret']) {
+      throw new BadRequestException(
+        `You must set the storage-spaces-secret in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-spaces-region']) {
+      throw new BadRequestException(
+        `You must set the storage-spaces-region in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-spaces-bucket']) {
+      throw new BadRequestException(
+        `You must set the storage-spaces-bucket in the setting.`,
+      );
+    }
+
+    const s3 = await this.getClient();
+
+    try {
+      await s3.send(
+        new HeadBucketCommand({
+          Bucket: this.setting['storage-spaces-bucket'],
+        }),
+      );
+    } catch (error) {
+      throw new BadRequestException(
+        `The bucket "${this.setting['storage-spaces-bucket']}" does not exist or you do not have access to it.`,
+      );
+    }
+  }
+
+  async getClient() {
+    if (this.S3) {
+      return this.S3;
+    }
+
+    const credentials = {
+      accessKeyId: this.setting['storage-spaces-key'],
+      secretAccessKey: this.setting['storage-spaces-secret'],
+    };
+
+    this.S3Client = new S3Client({
+      credentials,
+      endpoint: this.endpoint,
+      region: this.setting['storage-spaces-region'],
+      forcePathStyle: false,
+    });
+
+    return (this.S3 = new S3({
+      credentials,
+      endpoint: this.endpoint,
+      region: this.setting['storage-spaces-region'],
+      forcePathStyle: false,
+    }));
+  }
+
+  async getS3Client() {
+    if (this.S3Client) {
+      return this.S3Client;
+    }
+
+    this.S3Client = new S3Client({
+      credentials: {
+        accessKeyId: this.setting['storage-spaces-key'],
+        secretAccessKey: this.setting['storage-spaces-secret'],
+      },
+      endpoint: this.endpoint,
+      region: this.setting['storage-spaces-region'],
+      forcePathStyle: false,
+    });
+
+    return this.S3Client;
+  }
+
+  async buffer(filepath: string): Promise<Buffer> {
+    const s3 = await this.getClient();
+    const key = this.resolveKey(filepath);
+    const result = await s3.send(
+      new GetObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+      }),
+    );
+    // @ts-ignore
+    const stream = result.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  async upload(destination: string, file: MulterFile): Promise<any> {
+    const s3 = await this.getClient();
+    const storedFilename = this.getFilename(file.originalname);
+    const key = [destination, storedFilename].join('/');
+    await s3.send(
+      new PutObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+        Body: file.buffer,
+        ACL: 'public-read',
+      }),
+    );
+    return `${this.bucketUrl}/${key}`;
+  }
+
+  async uploadFromString(
+    destination: string,
+    filename: string,
+    fileContent: string,
+  ): Promise<any> {
+    const s3 = await this.getClient();
+    const storedFilename = this.getFilename(filename);
+    const key = [destination, storedFilename].join('/');
+    await s3.send(
+      new PutObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+        Body: fileContent,
+        ACL: 'public-read',
+      }),
+    );
+    return `${this.bucketUrl}/${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('/');
+    await s3.send(
+      new PutObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+        Body: createReadStream(filePath),
+        ContentType: options?.mimetype,
+        ACL: 'public-read',
+      }),
+    );
+    return `${this.bucketUrl}/${key}`;
+  }
+
+  async delete(filepath: string): Promise<any> {
+    const s3 = await this.getClient();
+    const key = this.resolveKey(filepath);
+    await s3.send(
+      new DeleteObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+      }),
+    );
+    return true;
+  }
+
+  async readStream(filepath: string): Promise<Readable> {
+    const s3 = await this.getClient();
+    const key = this.resolveKey(filepath);
+    const result = await s3.send(
+      new GetObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+      }),
+    );
+    // @ts-ignore
+    return result.Body as Readable;
+  }
+
+  async metaData(filepath: string): Promise<any> {
+    const s3 = await this.getClient();
+    const key = this.resolveKey(filepath);
+    const result = await s3.send(
+      new HeadObjectCommand({
+        Bucket: this.setting['storage-spaces-bucket'],
+        Key: key,
+      }),
+    );
+    return result;
+  }
+
+  async tempURL(filepath: string, expires = 3600): Promise<string> {
+    const s3Client = await this.getS3Client();
+    const key = this.resolveKey(filepath);
+    const command = new GetObjectCommand({
+      Bucket: this.setting['storage-spaces-bucket'],
+      Key: key,
+    });
+    return await getSignedUrl(s3Client as any, command, { expiresIn: expires });
+  }
+}

package/src/index.ts

@@ -19,11 +19,13 @@ export * from './screen/screen.service';
 export * from './user/constants/user.constants';
 export * from './user/user.service';
 
-export * from './mail-profile/mail-profile.module';
-export * from './mail-profile/mail-profile.service';
 export * from './mail/mail.module';
 export * from './mail/mail.service';
 
+export * from './integration-profile/integration-profile.module';
+export * from './integration-profile/integration-profile.service';
+export * from './integration-profile/integration-profile.utils';
+
 export * from './file/file.module';
 export * from './file/file.service';
 
@@ -72,6 +74,7 @@ export * from './utils/locale-context';
 
 
 // Notification Module
+export * from './notification/dto/create-notification.dto';
 export * from './notification/notification.module';
 export * from './notification/notification.service';
-export * from './notification/dto/create-notification.dto';
+

package/src/integration-profile/dto/create.dto.ts

@@ -0,0 +1,44 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsInt,
+  IsObject,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+
+export class CreateDTO {
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(255)
+  @Transform(({ value }) => String(value ?? '').trim())
+  slug: string;
+
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  @MaxLength(127)
+  @Transform(({ value }) => String(value ?? '').trim())
+  name: string;
+
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  type_id: number;
+
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  provider_id: number;
+
+  @IsOptional()
+  @IsObject()
+  config?: Record<string, unknown> | null;
+
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) =>
+    value === true || value === 'true' || value === 1 || value === '1',
+  )
+  is_active?: boolean;
+}

package/src/integration-profile/dto/export.dto.ts

@@ -0,0 +1,15 @@
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+export class ExportDTO {
+  @IsOptional()
+  @IsString()
+  ids?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) =>
+    value === true || value === 'true' || value === 1 || value === '1',
+  )
+  include_secrets?: boolean;
+}

package/src/integration-profile/dto/import-confirm.dto.ts

@@ -0,0 +1,61 @@
+import { Type } from 'class-transformer';
+import {
+  ArrayNotEmpty,
+  IsArray,
+  IsBoolean,
+  IsIn,
+  IsObject,
+  IsOptional,
+  IsString,
+  MaxLength,
+  ValidateNested,
+} from 'class-validator';
+
+export class ImportProfileItemDTO {
+  @IsString()
+  @MaxLength(255)
+  slug: string;
+
+  @IsString()
+  @MaxLength(127)
+  name: string;
+
+  @IsString()
+  @MaxLength(255)
+  type_slug: string;
+
+  @IsString()
+  @MaxLength(255)
+  provider_slug: string;
+
+  @IsOptional()
+  @IsObject()
+  config?: Record<string, unknown> | null;
+
+  @IsOptional()
+  @IsBoolean()
+  is_active?: boolean;
+}
+
+export class ConflictResolutionDTO {
+  @IsString()
+  @MaxLength(255)
+  slug: string;
+
+  @IsIn(['ignore', 'replace', 'rename_auto'])
+  action: 'ignore' | 'replace' | 'rename_auto';
+}
+
+export class ImportConfirmDTO {
+  @IsArray()
+  @ArrayNotEmpty()
+  @ValidateNested({ each: true })
+  @Type(() => ImportProfileItemDTO)
+  profiles: ImportProfileItemDTO[];
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => ConflictResolutionDTO)
+  conflict_resolutions?: ConflictResolutionDTO[];
+}

package/src/integration-profile/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}