fix(application-system): using aws-sdkv3 instead of v2 and refactoring

apps/application-system/form/src/components/Header/Header.tsx

@@ -23,7 +23,7 @@ export const Header: FC<React.PropsWithChildren<unknown>> = () => {
   }, [location])
 
   return (
-    <Box background="white">
+    <Box background="red600">
       <GridContainer>
         <UIHeader
           info={

libs/application/template-api-modules/src/lib/modules/shared/services/attachment-s3.service.ts

@@ -1,9 +1,13 @@
 import { getValueViaPath } from '@island.is/application/core'
-import { ApplicationWithAttachments as Application } from '@island.is/application/types'
-import { S3 } from 'aws-sdk'
-import AmazonS3URI from 'amazon-s3-uri'
+import { ApplicationWithAttachments } from '@island.is/application/types'
 import { logger } from '@island.is/logging'
-import { Injectable } from '@nestjs/common'
+import { Inject, Injectable } from '@nestjs/common'
+import { S3Service } from './s3.service'
+import { ConfigService } from '@nestjs/config'
+import {
+  BaseTemplateApiApplicationService,
+  BaseTemplateAPIModuleConfig,
+} from '../../../types'
 
 export interface AttachmentData {
   key: string
@@ -14,13 +18,16 @@ export interface AttachmentData {
 
 @Injectable()
 export class AttachmentS3Service {
-  private readonly s3: AWS.S3
-  constructor() {
-    this.s3 = new S3()
-  }
+  constructor(
+    @Inject(S3Service) private s3Service: S3Service,
+    @Inject(ConfigService)
+    private readonly configService: ConfigService<BaseTemplateAPIModuleConfig>,
+    @Inject(BaseTemplateApiApplicationService)
+    private readonly applicationService: BaseTemplateApiApplicationService,
+  ) {}
 
   public async getFiles(
-    application: Application,
+    application: ApplicationWithAttachments,
     attachmentAnswerKeys: string[],
   ): Promise<AttachmentData[]> {
     const attachments: AttachmentData[] = []
@@ -43,7 +50,7 @@ export class AttachmentS3Service {
       name: string
     }>,
     answerKey: string,
-    application: Application,
+    application: ApplicationWithAttachments,
   ): Promise<AttachmentData[]> {
     return await Promise.all(
       answers.map(async ({ key, name }) => {
@@ -58,30 +65,73 @@ export class AttachmentS3Service {
           return { key: '', fileContent: '', answerKey, fileName: '' }
         }
         const fileContent =
-          (await this.getApplicationFilecontentAsBase64(url)) ?? ''
+          (await this.s3Service.getFileContentAsBase64(url)) ?? ''
 
         return { key, fileContent, answerKey, fileName: name }
       }),
     )
   }
 
-  private async getApplicationFilecontentAsBase64(
-    fileName: string,
-  ): Promise<string | undefined> {
-    const { bucket, key } = AmazonS3URI(fileName)
-    const uploadBucket = bucket
-    try {
-      const file = await this.s3
-        .getObject({
-          Bucket: uploadBucket,
-          Key: key,
-        })
-        .promise()
-      const fileContent = file.Body as Buffer
-      return fileContent?.toString('base64')
-    } catch (error) {
-      logger.error(error)
-      return undefined
+  public async getAttachmentContentAsBase64(
+    application: ApplicationWithAttachments,
+    attachmentKey: string,
+  ): Promise<string> {
+    const fileContent =
+      await this.s3Service.getFileFromApplicationWithAttachments(
+        application,
+        attachmentKey,
+      )
+    return fileContent?.Body?.transformToString('base64') || ''
+  }
+
+  public async getAttachmentContentAsBlob(
+    application: ApplicationWithAttachments,
+    attachmentKey: string,
+  ): Promise<Blob> {
+    const file = await this.s3Service.getFileFromApplicationWithAttachments(
+      application,
+      attachmentKey,
+    )
+    const fileArrayBuffer = await file?.Body?.transformToByteArray()
+    return new Blob([fileArrayBuffer as ArrayBuffer], {
+      type: file?.ContentType,
+    })
+  }
+
+  public async getAttachmentUrl(
+    key: string,
+    expiration: number,
+  ): Promise<string> {
+    if (expiration <= 0) {
+      return Promise.reject('expiration must be positive')
     }
+
+    const bucket = this.configService.get('attachmentBucket') as
+      | string
+      | undefined
+
+    if (bucket == undefined) {
+      return Promise.reject('could not find s3 bucket')
+    }
+
+    return this.s3Service.getSignedUrlPromise(bucket, key, expiration)
+  }
+
+  public async addAttachment(
+    application: ApplicationWithAttachments,
+    fileName: string,
+    buffer: Buffer,
+    uploadParameters?: {
+      ContentType?: string
+      ContentDisposition?: string
+      ContentEncoding?: string
+    },
+  ): Promise<string> {
+    return this.applicationService.saveAttachmentToApplicaton(
+      application,
+      fileName,
+      buffer,
+      uploadParameters,
+    )
   }
 }

libs/application/template-api-modules/src/lib/modules/shared/services/s3.service.spec.ts

@@ -0,0 +1,62 @@
+import { Test, TestingModule } from '@nestjs/testing'
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3'
+import { mockClient } from 'aws-sdk-client-mock'
+import { Readable } from 'stream'
+import { sdkStreamMixin } from '@smithy/util-stream'
+import { logger, LOGGER_PROVIDER } from '@island.is/logging'
+import { S3Service } from './s3.service'
+
+const s3Mock = mockClient(S3Client)
+
+describe('S3Service', () => {
+  let s3Service: S3Service
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        S3Service,
+        {
+          provide: LOGGER_PROVIDER,
+          useClass: jest.fn(() => ({
+            error: () => ({}),
+          })),
+        },
+        {
+          provide: S3Client,
+          useValue: s3Mock,
+        },
+      ],
+    }).compile()
+
+    s3Service = module.get<S3Service>(S3Service)
+
+    s3Mock.reset()
+  })
+
+  it('should return a file from a bucket if one exists', async () => {
+    const expectedResult = 'hello world'
+
+    const stream = new Readable()
+    stream.push(expectedResult)
+    stream.push(null) // end of stream
+    const sdkStream = sdkStreamMixin(stream)
+
+    s3Mock.on(GetObjectCommand).resolvesOnce({ Body: sdkStream })
+
+    const getObjectResult = await s3Service.getFileFromBucket('bucekt', 'key')
+    if (!getObjectResult) fail('getObjectResult was undefined')
+
+    const contentResults = await getObjectResult.Body?.transformToString()
+    if (!contentResults) fail('raw transform result was undefined or empty')
+
+    expect(contentResults).toStrictEqual(expectedResult)
+  })
+
+  it('should return undefined from a bucket when an error is thrown', async () => {
+    s3Mock.on(GetObjectCommand).rejectsOnce()
+
+    const getObjectResult = await s3Service.getFileFromBucket('bucekt', 'key')
+
+    expect(getObjectResult).toBeUndefined()
+  })
+})

libs/application/template-api-modules/src/lib/modules/shared/services/s3.service.ts

@@ -0,0 +1,125 @@
+import {
+  GetObjectCommand,
+  GetObjectCommandOutput,
+  S3Client,
+} from '@aws-sdk/client-s3'
+import AmazonS3URI from 'amazon-s3-uri'
+import { Inject, Injectable } from '@nestjs/common'
+import { ApplicationWithAttachments } from '@island.is/application/types'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { LOGGER_PROVIDER, type Logger } from '@island.is/logging'
+
+@Injectable()
+export class S3Service {
+  constructor(
+    @Inject(S3Client) private s3Client: S3Client,
+    @Inject(LOGGER_PROVIDER) protected readonly logger: Logger,
+  ) {}
+
+  public async getSignedUrlPromise(
+    bucket: string,
+    key: string,
+    expiration: number,
+  ): Promise<string> {
+    try {
+      const command = new GetObjectCommand({ Bucket: bucket, Key: key })
+      const url = await getSignedUrl(this.s3Client, command, {
+        expiresIn: expiration,
+      })
+      return url ?? ''
+    } catch (error) {
+      this.logger.error('Error occurred while fetching file from S3')
+      this.logger.error(error)
+      return ''
+    }
+  }
+
+  public async getFileFromBucket(
+    bucket: string,
+    key: string,
+  ): Promise<GetObjectCommandOutput | undefined> {
+    try {
+      const result = await this.s3Client.send(
+        new GetObjectCommand({
+          Bucket: bucket,
+          Key: key,
+        }),
+      )
+
+      return result
+    } catch (error) {
+      this.logger.error('Error occurred while fetching file from S3')
+      this.logger.error(error)
+      return undefined
+    }
+  }
+
+  public async getFileFromApplicationWithAttachments(
+    application: ApplicationWithAttachments,
+    attachmentKey: string,
+  ): Promise<GetObjectCommandOutput | undefined> {
+    const fileName = (
+      application.attachments as {
+        [key: string]: string
+      }
+    )[attachmentKey]
+
+    const { bucket, key } = AmazonS3URI(fileName)
+    const uploadBucket = bucket
+    try {
+      const result = await this.s3Client.send(
+        new GetObjectCommand({
+          Bucket: uploadBucket,
+          Key: key,
+        }),
+      )
+
+      return result
+    } catch (error) {
+      this.logger.error('Error occurred while fetching file from S3')
+      this.logger.error(error)
+      return undefined
+    }
+  }
+
+  public async getFileContentAsBase64(
+    fileName: string,
+  ): Promise<string | undefined> {
+    const { bucket, key } = AmazonS3URI(fileName)
+    const uploadBucket = bucket
+    try {
+      const { Body } = await this.s3Client.send(
+        new GetObjectCommand({
+          Bucket: uploadBucket,
+          Key: key,
+        }),
+      )
+
+      return await Body?.transformToString('base64')
+    } catch (error) {
+      this.logger.error('Error occurred while fetching file from S3')
+      this.logger.error(error)
+      return undefined
+    }
+  }
+
+  public async getFileContentAsBase64FromBucket(
+    bucket: string,
+    key: string,
+  ): Promise<string | undefined> {
+    try {
+      const { Body } = await this.s3Client.send(
+        new GetObjectCommand({
+          Bucket: bucket,
+          Key: key,
+        }),
+      )
+
+      return await Body?.transformToString('base64')
+    } catch (error) {
+      this.logger.error('Error occurred while fetching file from S3')
+      this.logger.error(error)
+      return undefined
+    }
+  }
+}

libs/application/template-api-modules/src/lib/modules/shared/shared.module.ts

@@ -11,6 +11,8 @@ import { SharedTemplateApiService } from './shared.service'
 import { SmsModule } from '@island.is/nova-sms'
 import { PaymentModule } from '@island.is/application/api/payment'
 import { AttachmentS3Service } from './services'
+import { S3Service } from './services/s3.service'
+import { S3Client } from '@aws-sdk/client-s3'
 
 export class SharedTemplateAPIModule {
   static register(config: BaseTemplateAPIModuleConfig): DynamicModule {
@@ -34,9 +36,14 @@ export class SharedTemplateAPIModule {
           provide: BaseTemplateApiApplicationService,
           useClass: config.applicationService,
         },
+        {
+          provide: S3Client,
+          useValue: new S3Client(),
+        },
+        S3Service,
         AttachmentS3Service,
       ],
-      exports: [SharedTemplateApiService, AttachmentS3Service],
+      exports: [SharedTemplateApiService, S3Service, AttachmentS3Service],
     }
   }
 }