feat!: replace existing user file(-system) abstraction with a new one

The new abstraction uniquely identifies users and each file system.
Right now, file systems are still hard coded (including their IDs).

With this, I also introduce the Apollo-URLs (`apollo://`),
that can be used to identify files across file systems or even users.
This lays the foundation for file sharing with other users and much more.

Author: SpraxDev

src/AbstractUser.ts

@@ -1,19 +1,19 @@
-import IUserFile from './files/IUserFile';
+import VirtualFile from './user/files/VirtualFile';
 
 export default class FileSearch {
-  static async searchFile(file: IUserFile, query: string): Promise<IUserFile[]> {
+  static async searchFile(file: VirtualFile, query: string): Promise<VirtualFile[]> {
     if (!await file.isDirectory()) {
       throw new Error('File is not a directory');
     }
 
     return this.searchFileRecursive(await file.getFiles(), query);
   }
 
-  private static async searchFileRecursive(files: IUserFile[], query: string): Promise<IUserFile[]> {
+  private static async searchFileRecursive(files: VirtualFile[], query: string): Promise<VirtualFile[]> {
     const result = [];
 
     for (const file of files) {
-      if (file.getName().toLowerCase().includes(query.toLowerCase())) {
+      if (file.getFileName().toLowerCase().includes(query.toLowerCase())) {
         result.push(file);
       }
 

src/FileSearch.ts

@@ -1,8 +1,8 @@
 import Path from 'node:path';
 import sharp, { Sharp } from 'sharp';
-import IUserFile from './files/IUserFile';
 import VideoAnalyser from './media/video/analyser/VideoAnalyser';
 import ProcessBuilder from './process_manager/ProcessBuilder';
+import LocalFile from './user/files/local/LocalFile';
 
 export default class ThumbnailGenerator {
   readonly sharpMimeTypes: string[];
@@ -54,7 +54,7 @@ export default class ThumbnailGenerator {
    * FIXME: Everything below has been copied from NASWeb, the predecessor of Apollo – This needs heavy refactoring :p
    */
 
-  async generateThumbnail(file: IUserFile): Promise<{ mime: string, data: Buffer } | null> {
+  async generateThumbnail(file: LocalFile): Promise<{ mime: string, data: Buffer } | null> {
     const mimeType = await file.getMimeType();
 
     if (mimeType == null) {
@@ -110,9 +110,8 @@ export default class ThumbnailGenerator {
     };
   }
 
-  private async extractVideoCover(file: IUserFile): Promise<Sharp | null> {
-    const filePath = await file.getAbsolutePathOnHost();
-    if (filePath == null) throw new Error('filePath is null');
+  private async extractVideoCover(file: LocalFile): Promise<Sharp | null> {
+    const filePath = file.getAbsolutePathOnHost();
 
     const videoStreams = await VideoAnalyser.analyze(filePath, true);
     const potentialCoverStreams = videoStreams.streams.filter(stream => stream.codecType == 'video' && stream.avgFrameRate == '0/0');
@@ -135,11 +134,8 @@ export default class ThumbnailGenerator {
 
     // FIXME: Delete cwd when done
     // FIXME: write lock on cwd
-    const cwdFile = await file.getOwner().getTmpFileSystem().createTmpDir('thumbnail-');
+    const cwdFile = await file.fileSystem.owner.getTmpFileSystem().createTmpDir('thumbnail-');
     const cwd = cwdFile.getAbsolutePathOnHost();
-    if (cwd == null) {
-      throw new Error('cwd is null');
-    }
 
     const args = ['-i', filePath, '-map', coverStream.streamSpecifier, '-frames', '1', '-f', 'image2', coverStream.fileName];
 
@@ -155,12 +151,10 @@ export default class ThumbnailGenerator {
     return sharp(Path.join(cwd, coverStream.fileName));
   }
 
-  private static async generateVideoThumbnail(file: IUserFile, sampleSize: number = 3, width = 500): Promise<{ img: Sharp }> {
+  private static async generateVideoThumbnail(file: LocalFile, sampleSize: number = 3, width = 500): Promise<{ img: Sharp }> {
     if (sampleSize <= 0) throw new Error('sampleSize has to be positive');
 
-    const filePath = await file.getAbsolutePathOnHost();
-
-    if (filePath == null) throw new Error('filePath is null');
+    const filePath = file.getAbsolutePathOnHost();
 
     let videoDuration = 0;
 
@@ -183,11 +177,8 @@ export default class ThumbnailGenerator {
 
     // FIXME: Delete cwd when done
     // FIXME: write lock on cwd
-    const cwdFile = await file.getOwner().getTmpFileSystem().createTmpDir('thumbnail-');
+    const cwdFile = await file.fileSystem.owner.getTmpFileSystem().createTmpDir('thumbnail-');
     const cwd = cwdFile.getAbsolutePathOnHost();
-    if (cwd == null) {
-      throw new Error('cwd is null');
-    }
 
     const args = ['-i', filePath];
     args.unshift('-ss', Math.floor(0.1 * videoDuration).toString(), '-noaccurate_seek');

src/IUserStorage.ts

@@ -1,14 +1,14 @@
-import IUserFile from './files/IUserFile';
+import VirtualFile from './user/files/VirtualFile';
 
 export default class UserFileHelper {
-  static findFolderPoster(directory: IUserFile): Promise<IUserFile | null> {
+  static findFolderPoster(directory: VirtualFile): Promise<VirtualFile | null> {
     return UserFileHelper.findFirstFileMatchingInDirectory(directory, /^(?:poster|folder|cover)\.(?:png|jpg|jpeg|webp)$/ig);
   }
 
-  static async findFirstFileMatchingInDirectory(directory: IUserFile, fileNamePattern: RegExp): Promise<IUserFile | null> {
+  static async findFirstFileMatchingInDirectory(directory: VirtualFile, fileNamePattern: RegExp): Promise<VirtualFile | null> {
     const files = await directory.getFiles(); // TODO: Replace with a walk
     for (const file of files) {
-      if (fileNamePattern.test(file.getName())) {
+      if (fileNamePattern.test(file.getFileName())) {
         return file;
       }
     }

src/ThumbnailGenerator.ts

@@ -1,10 +1,10 @@
 import express from 'express';
 import Fs from 'node:fs';
 import Path from 'node:path';
-import IUserFile from './files/IUserFile';
+import VirtualFile from './user/files/VirtualFile';
 
 export default class Utils {
-  static async sendFileRespectingRequestedRange(req: express.Request, res: express.Response, next: express.NextFunction, file: string | IUserFile, mimeType: string, sendAsAttachment: boolean = false): Promise<void> {
+  static async sendFileRespectingRequestedRange(req: express.Request, res: express.Response, next: express.NextFunction, file: string | VirtualFile, mimeType: string, sendAsAttachment: boolean = false): Promise<void> {
     let fileStat: Fs.Stats;
 
     if (typeof file === 'string') {
@@ -53,7 +53,7 @@ export default class Utils {
     res.setHeader('Accept-Ranges', 'bytes');
 
     if (sendAsAttachment) {
-      res.setHeader('Content-Disposition', `attachment; filename="${Utils.tryReplacingBadCharactersForFileName(typeof file == 'string' ? Path.basename(file) : file.getName())}"`);
+      res.setHeader('Content-Disposition', `attachment; filename="${Utils.tryReplacingBadCharactersForFileName(typeof file == 'string' ? Path.basename(file) : file.getFileName())}"`);
     }
 
     res.setHeader('Content-Length', fileSize);

src/UserFileHelper.ts

@@ -1,6 +1,6 @@
 import NodeCache from 'node-cache';
 import Fs from 'node:fs';
-import IUserFile from '../files/IUserFile';
+import LocalFile from '../user/files/local/LocalFile';
 
 export default class FileStatCache {
   private readonly cache: NodeCache;
@@ -16,43 +16,42 @@ export default class FileStatCache {
     this.cache.flushAll();
   }
 
-  async clearFile(file: IUserFile): Promise<void> {
+  async clearFile(file: LocalFile): Promise<void> {
     const cacheClear = Promise.all([
       this.getCacheKey(file, 'stat').then(key => this.cache.del(key)),
       this.getCacheKey(file, 'mimeType').then(key => this.cache.del(key))
     ]);
 
-    if (file.getPath().lastIndexOf('/') === 0) {
+    if (file.path.lastIndexOf('/') === 0) {
       this.cache.keys()
         .filter(key => key.endsWith(`:directorySize`))
         .forEach(key => this.cache.del(key));
     } else {
-      const subdirPath = file.getFileSystem().getFile(file.getPath().substring(0, file.getPath().indexOf('/', 1) + 1)).getAbsolutePathOnHost();
+      const subDirPath = file.fileSystem.getFile(file.path.substring(0, file.path.indexOf('/', 1) + 1)).getAbsolutePathOnHost();
 
-      if (subdirPath != null) {
+      if (subDirPath != null) {
         this.cache.keys()
-          .filter(key => key.startsWith(subdirPath))
+          .filter(key => key.startsWith(subDirPath))
           .forEach(key => this.cache.del(key));
       }
     }
 
-
     await cacheClear;
   }
 
-  async setStat(file: IUserFile, stat: Fs.Stats): Promise<void> {
+  async setStat(file: LocalFile, stat: Fs.Stats): Promise<void> {
     this.cache.set(await this.getCacheKey(file, 'stat'), stat);
   }
 
-  async getStat(file: IUserFile): Promise<Fs.Stats | undefined> {
+  async getStat(file: LocalFile): Promise<Fs.Stats | undefined> {
     return this.cache.get(await this.getCacheKey(file, 'stat'));
   }
 
-  async setMimeType(file: IUserFile, mimeType: string | null): Promise<void> {
+  async setMimeType(file: LocalFile, mimeType: string | null): Promise<void> {
     this.cache.set(await this.getCacheKey(file, 'mimeType'), mimeType);
   }
 
-  async getMimeType(file: IUserFile): Promise<string | null | undefined> {
+  async getMimeType(file: LocalFile): Promise<string | null | undefined> {
     return this.cache.get(await this.getCacheKey(file, 'mimeType'));
   }
 
@@ -64,7 +63,7 @@ export default class FileStatCache {
     return this.cache.get(`${filePath}:directorySize`);
   }
 
-  private async getCacheKey(file: IUserFile, type: 'stat' | 'mimeType'): Promise<string> {
+  private async getCacheKey(file: LocalFile, type: 'stat' | 'mimeType'): Promise<string> {
     return `${await file.generateCacheId()}:${type}`;
   }
 }

src/UserStorage.ts

@@ -1,23 +1,23 @@
 import Crypto from 'node:crypto';
 import Fs from 'node:fs';
 import Path from 'node:path';
-import AbstractUser from '../AbstractUser';
 import { getAppTmpDir } from '../Constants';
+import ApolloUser from '../user/ApolloUser';
 
 export default class FileSystemBasedCache {
   private static INSTANCE: FileSystemBasedCache;
 
   protected constructor() {
   }
 
-  async setUserAssociatedCachedFile(user: AbstractUser, cacheSubKey: string, data: Buffer): Promise<void> {
+  async setUserAssociatedCachedFile(user: ApolloUser, cacheSubKey: string, data: Buffer): Promise<void> {
     const cacheFilePath = this.generateUserAssociatedCacheFilePath(user, cacheSubKey);
 
     await Fs.promises.mkdir(Path.dirname(cacheFilePath), { recursive: true });
     await Fs.promises.writeFile(cacheFilePath, data);
   }
 
-  async getUserAssociatedCachedFile(user: AbstractUser, cacheSubKey: string): Promise<Buffer | null> {
+  async getUserAssociatedCachedFile(user: ApolloUser, cacheSubKey: string): Promise<Buffer | null> {
     const cacheFilePath = this.generateUserAssociatedCacheFilePath(user, cacheSubKey);
 
     if (!Fs.existsSync(cacheFilePath)) {
@@ -26,13 +26,13 @@ export default class FileSystemBasedCache {
     return Fs.promises.readFile(cacheFilePath);
   }
 
-  private generateUserAssociatedCacheFilePath(user: AbstractUser, cacheSubKey: string): string {
+  private generateUserAssociatedCacheFilePath(user: ApolloUser, cacheSubKey: string): string {
     const cacheFileName = Crypto
       .createHash('sha256')
       .update(cacheSubKey)
       .digest('base64');
 
-    return Path.join(getAppTmpDir(), 'fileSystemBasedCache', user.getId().toString(), cacheFileName);
+    return Path.join(getAppTmpDir(), 'fileSystemBasedCache', user.id.toString(), cacheFileName);
   }
 
   static getInstance(): FileSystemBasedCache {