feat(file-uploader): added upload router

app-config.yaml

@@ -1,5 +1,6 @@
 httpApi:
   host: 0.0.0.0
+  fileSizeLimit: 1000000
   port: 1337
   allowedOrigins: '*'
   cookieSecret: 'secret'
@@ -27,6 +28,11 @@ logging:
   appServer: info
   database: info
 
+s3:
+  accessKeyId: 'secret'
+  secretAccessKey: 'secret'
+  endpoint: 'http://localhost:9000'
+
 database:
   dsn: 'postgres://codex:postgres@postgres:5432/notes'
 

migrations/tenant/0028-files@add-column-size.sql

@@ -0,0 +1,72 @@
+DO $$
+BEGIN
+  -- Add sixe column if it not exists
+  IF NOT EXISTS (
+    SELECT 1
+    FROM   information_schema.columns
+    WHERE  table_name = 'files'
+    AND    column_name = 'size'
+  )
+  THEN
+    ALTER TABLE files ADD COLUMN size integer NOT NULL;
+  END IF;
+
+  -- Make id column autoincrementing
+  CREATE SEQUENCE IF NOT EXISTS public.files_id_seq
+    AS integer
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+
+
+-- Make identifier default value incrementing
+  ALTER TABLE ONLY public.files ALTER COLUMN id SET DEFAULT nextval('public.files_id_seq'::regclass);
+
+  -- Remove column note_id
+  IF EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_name = 'files'
+        AND column_name = 'note_id'
+    ) THEN
+        -- Drop the column if it exists
+        ALTER TABLE files
+        DROP COLUMN note_id;
+  END IF;
+
+  -- Add column location
+  IF NOT EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_name = 'files'
+        AND column_name = 'location'
+    ) THEN
+        ALTER TABLE files
+        ADD COLUMN location JSONB;
+  END IF;
+
+  -- Remove column user_id
+  IF EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_name = 'files'
+        AND column_name = 'user_id'
+    ) THEN
+        -- Drop the column if it exists
+        ALTER TABLE files
+        DROP COLUMN user_id;
+  END IF;
+
+  -- Add column metadata
+  IF NOT EXISTS (
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_name = 'files'
+        AND column_name = 'metadata'
+    ) THEN
+        ALTER TABLE files
+        ADD COLUMN metadata JSONB;
+  END IF;
+END $$;

package.json

@@ -39,6 +39,7 @@
     "@codex-team/config-loader": "^1.0.0",
     "@fastify/cookie": "^8.3.0",
     "@fastify/cors": "^8.3.0",
+    "@fastify/multipart": "^8.1.0",
     "@fastify/oauth2": "^7.2.1",
     "@fastify/swagger": "^8.8.0",
     "@fastify/swagger-ui": "^1.9.3",
@@ -48,6 +49,7 @@
     "fastify": "^4.17.0",
     "http-status-codes": "^2.2.0",
     "jsonwebtoken": "^9.0.0",
+    "mime": "^4.0.1",
     "nanoid": "^4.0.2",
     "pg": "^8.11.0",
     "pg-hstore": "^2.3.4",

src/domain/entities/file.ts

@@ -1,15 +1,55 @@
 import type { NoteInternalId } from './note.js';
-import type User from './user.js';
 import type { Buffer } from 'buffer';
+import type User from './user.js';
 
 /**
  * File types for storing in object storage
  */
-export enum FileTypes {
+export enum FileType {
+  /**
+   * Type for testing uploads
+   */
+  Test = 0,
+
   /**
-   * @todo define real types
+   * File is a part of note
    */
-  test = 'test',
+  NoteAttachment = 1,
+}
+
+/**
+ * Additional data about uploaded file, ex. user id, who uploaded it
+ */
+export interface FileMetadata {
+  /**
+   * User who uploaded file
+   */
+  userId: User['id'];
+}
+
+/**
+ * File location for testing uploads, there is no defined location
+ */
+export type TestFileLocation = Record<never, never>;
+
+/**
+ * File location, when it is a part of note
+ */
+export type NoteAttachmentFileLocation = {
+  noteId: NoteInternalId,
+};
+
+/**
+ * Possible file location
+ */
+export type FileLocation = TestFileLocation | NoteAttachmentFileLocation;
+
+/**
+ * File location type, wich depends on file type
+ */
+export interface FileLocationByType {
+  [FileType.Test]: TestFileLocation,
+  [FileType.NoteAttachment]: NoteAttachmentFileLocation,
 }
 
 /**
@@ -26,11 +66,6 @@ export default interface UploadedFile {
    */
   key: string;
 
-  /**
-   * User who uploaded the file
-   */
-  userId?: User['id'];
-
   /**
    * File name
    */
@@ -44,7 +79,7 @@ export default interface UploadedFile {
   /**
    * File type, using to store in object storage
    */
-  type: FileTypes;
+  type: FileType;
 
   /**
    * File size in bytes
@@ -57,9 +92,14 @@ export default interface UploadedFile {
   createdAt: Date;
 
   /**
-   * In case if file is a part of note, note id to identify permissions to access
+   * Object, which stores information about file location
+   */
+  location: FileLocation;
+
+  /**
+   * File metadata
    */
-  noteId?: NoteInternalId;
+  metadata: FileMetadata;
 }
 
 /**

src/domain/service/fileUploader.service.ts

@@ -1,16 +1,16 @@
-import type { FileData } from '@domain/entities/file.js';
-import { FileTypes } from '@domain/entities/file.js';
-import type { NoteInternalId } from '@domain/entities/note.js';
-import type User from '@domain/entities/user.js';
+import type { FileData, NoteAttachmentFileLocation, FileLocationByType, FileLocation, FileMetadata } from '@domain/entities/file.js';
+import type UploadedFile from '@domain/entities/file.js';
+import { FileType } from '@domain/entities/file.js';
 import { createFileId } from '@infrastructure/utils/id.js';
 import type FileRepository from '@repository/file.repository.js';
 import type ObjectRepository from '@repository/object.repository.js';
 import { DomainError } from '@domain/entities/DomainError.js';
+import mime from 'mime';
 
 /**
  * File data for upload
  */
-interface FileToUpload {
+interface UploadFileData {
   /**
    * File data
    */
@@ -23,25 +23,6 @@ interface FileToUpload {
    * Mimetype of the file
    */
   mimetype: string;
-  /**
-   * File type
-   */
-  type: FileTypes;
-}
-
-/**
- * File upload details, contains user id, who uploaded the file and note id, in case if file is a part of note
- */
-interface FileUploadDetails {
-  /**
-   * User who uploaded the file
-   */
-  userId?: User['id'];
-
-  /**
-   * In case if file is a part of note, note id to identify permissions to access
-   */
-  noteId?: NoteInternalId;
 }
 
 /**
@@ -72,13 +53,30 @@ export default class FileUploaderService {
   /**
    * Upload file
    *
-   * @param fileData - file data to upload (e.g. buffer, name, mimetype)
-   * @param details - file upload details (e.g. user id, note id)
+   * @param fileData - file data, including file data, name and mimetype
+   * @param location - file location depending on type
+   * @param metadata - file metadata, including user id who uploaded the file
    */
-  public async uploadFile(fileData: FileToUpload, details?: FileUploadDetails): Promise<string> {
-    const key = createFileId();
+  public async uploadFile(fileData: UploadFileData, location: FileLocation, metadata: FileMetadata): Promise<string> {
+    const type = this.defineFileType(location);
+
+    const fileHash = createFileId();
+
+    /**
+     * Extension can be null if file mime type is unknown or not supported
+     */
+    const fileExtension = mime.getExtension(fileData.mimetype);
+
+    if (fileExtension === null) {
+      throw new DomainError('Unknown file extension');
+    }
 
-    const bucket = this.defineBucketByFileType(fileData.type);
+    /**
+     * Key is a combination of file hash and file extension, separated by dot, e.g. `HgduSDGmsdrs.png`
+     */
+    const key = `${fileHash}.${fileExtension}`;
+
+    const bucket = this.defineBucketByFileType(type);
 
     const uploaded = await this.objectRepository.insert(fileData.data, key, bucket);
 
@@ -88,25 +86,50 @@ export default class FileUploaderService {
 
     const file = await this.fileRepository.insert({
       ...fileData,
+      type,
       key,
-      userId: details?.userId,
-      noteId: details?.noteId,
+      metadata,
+      location: location,
       size: fileData.data.length,
     });
 
     if (file === null) {
-      throw new Error('File was not uploaded');
+      throw new DomainError('File was not uploaded');
     }
 
     return file.key;
   }
 
+  /**
+   * Get file location by key and type
+   * Returns null if where is no such file
+   *
+   * @param type - file type
+   * @param key - file unique key
+   */
+  public async getFileLocationByKey<T extends FileType>(type: T, key: UploadedFile['key']): Promise<FileLocationByType[T] | null> {
+    return await this.fileRepository.getFileLocationByKey(type, key);
+  }
+
   /**
    * Get file data by key
    *
    * @param objectKey - unique file key in object storage
+   * @param location - file location
    */
-  public async getFileDataByKey(objectKey: string): Promise<FileData> {
+  public async getFileData(objectKey: string, location: FileLocation): Promise<FileData> {
+    /**
+     * If type of requested file is note attchement, we need to check if saved file location is the same of requested
+     */
+    if (this.isNoteAttachemntFileLocation(location)) {
+      const fileType = FileType.NoteAttachment;
+      const fileLocationFromStorage = await this.fileRepository.getFileLocationByKey(fileType, objectKey);
+
+      if (fileLocationFromStorage === null || location.noteId !== fileLocationFromStorage.noteId) {
+        throw new DomainError('File not found');
+      }
+    }
+
     const file = await this.fileRepository.getByKey(objectKey);
 
     if (file === null) {
@@ -124,17 +147,42 @@ export default class FileUploaderService {
     return fileData;
   }
 
+
+  /**
+   * Define file type by location
+   *
+   * @param location - file location
+   */
+  private defineFileType(location: FileLocation): FileType {
+    if (this.isNoteAttachemntFileLocation(location)) {
+      return FileType.NoteAttachment;
+    }
+
+    return FileType.Test;
+  }
+
+  /**
+   * Check if file location is note attachemnt
+   *
+   * @param location - to check
+   */
+  private isNoteAttachemntFileLocation(location: FileLocation): location is NoteAttachmentFileLocation {
+    return 'noteId' in location;
+  }
+
   /**
    * Define bucket name by file type
    *
    * @param fileType - file type
    */
-  private defineBucketByFileType(fileType: FileTypes): string {
+  private defineBucketByFileType(fileType: FileType): string {
     switch (fileType) {
-      case FileTypes.test:
+      case FileType.Test:
         return 'test';
+      case FileType.NoteAttachment:
+        return 'note-attachment';
       default:
-        throw new Error('Unknown file type');
+        throw new DomainError('Unknown file type');
     }
   }
 }