@hed-hog/core 0.0.355 → 0.0.358

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

@@ -0,0 +1,246 @@
+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();
+  }
+
+  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');
+    }
+    return filepath;
+  }
+
+  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 storedFilename;
+  }
+
+  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 storedFilename;
+  }
+
+  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 storedFilename;
+  }
+
+  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/integration-profile.controller.ts

@@ -0,0 +1,131 @@
+import { DeleteDTO, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Header,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+  Res,
+  UploadedFile,
+  UseInterceptors,
+  forwardRef,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { Response } from 'express';
+import { CreateDTO } from './dto/create.dto';
+import { ExportDTO } from './dto/export.dto';
+import { ImportConfirmDTO } from './dto/import-confirm.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { IntegrationProfileService } from './integration-profile.service';
+
+@Role()
+@Controller('integration-profile')
+export class IntegrationProfileController {
+  constructor(
+    @Inject(forwardRef(() => IntegrationProfileService))
+    private readonly integrationProfileService: IntegrationProfileService,
+  ) {}
+
+  @Get('types')
+  async listTypes() {
+    return this.integrationProfileService.listTypes();
+  }
+
+  @Get('providers')
+  async listProviders(
+    @Query('typeId') typeId?: string,
+    @Query('typeSlug') typeSlug?: string,
+  ) {
+    return this.integrationProfileService.listProviders(
+      typeId ? parseInt(typeId, 10) : undefined,
+      typeSlug,
+    );
+  }
+
+  @Get()
+  async list(
+    @Pagination() paginationParams,
+    @Query('typeId') typeId?: string,
+    @Query('typeSlug') typeSlug?: string,
+    @Query('providerSlug') providerSlug?: string,
+  ) {
+    return this.integrationProfileService.list(
+      paginationParams,
+      typeId ? parseInt(typeId, 10) : undefined,
+      typeSlug,
+      providerSlug,
+    );
+  }
+
+  @Get('export')
+  @Header('Content-Type', 'application/octet-stream')
+  @Header(
+    'Content-Disposition',
+    'attachment; filename="integration-profiles.hedhog"',
+  )
+  async export(
+    @Query() { ids, include_secrets = false }: ExportDTO,
+    @Res() res: Response,
+  ) {
+    const parsedIds = String(ids ?? '')
+      .split(',')
+      .map((value) => Number(value.trim()))
+      .filter((value) => Number.isInteger(value) && value > 0);
+
+    const file = await this.integrationProfileService.exportProfiles({
+      ids: parsedIds.length > 0 ? parsedIds : undefined,
+      includeSecrets: include_secrets,
+    });
+
+    res.send(file);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.integrationProfileService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.integrationProfileService.create(data);
+  }
+
+  @Post('test')
+  async test(@Body() data: CreateDTO) {
+    return this.integrationProfileService.test(data);
+  }
+
+  @Patch(':id')
+  async update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.integrationProfileService.update({ id, data });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.integrationProfileService.delete(data);
+  }
+
+  @UseInterceptors(FileInterceptor('file'))
+  @Post('import/validate')
+  async validateImport(@UploadedFile() file: MulterFile) {
+    return this.integrationProfileService.validateImportFile(file);
+  }
+
+  @Post('import/confirm')
+  async confirmImport(@Body() data: ImportConfirmDTO) {
+    return this.integrationProfileService.confirmImport({
+      profiles: data.profiles,
+      conflictResolutions: data.conflict_resolutions,
+    });
+  }
+}

package/src/integration-profile/integration-profile.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 { IntegrationProfileController } from './integration-profile.controller';
+import { IntegrationProfileService } from './integration-profile.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+  controllers: [IntegrationProfileController],
+  providers: [IntegrationProfileService],
+  exports: [IntegrationProfileService],
+})
+export class IntegrationProfileModule {}