Merge pull request #517 from internxt/fix/auth-check-hook

larryrider · web-flow · commit bccbb6f1ada0 · 2026-03-12T15:36:19.000+01:00
[_]: fix/auth-check-hook
diff --git a/src/commands/config.ts b/src/commands/config.ts
@@ -4,6 +4,9 @@ import { CLIUtils } from '../utils/cli.utils';
 import { UsageService } from '../services/usage.service';
 import { FormatUtils } from '../utils/format.utils';
 import { Header } from 'tty-table';
+import { AsyncUtils } from '../utils/async.utils';
+
+const MAX_USAGE_TIMEOUT = 15_000;
 
 export default class Config extends Command {
   static readonly args = {};
@@ -25,8 +28,7 @@ export default class Config extends Command {
 
     const userCredentials = await ConfigService.instance.readUser();
     if (userCredentials?.user) {
-      const usedSpace = FormatUtils.humanFileSize(await UsageService.instance.fetchUsage());
-      const availableSpace = FormatUtils.formatLimit(await UsageService.instance.fetchSpaceLimit());
+      const [usedSpace, availableSpace] = await Promise.all([this.tryGetUsage(), this.tryGetSpaceLimit()]);
 
       const configList = [
         { key: 'Email', value: userCredentials.user.email },
@@ -65,4 +67,30 @@ export default class Config extends Command {
     });
     this.exit(1);
   };
+
+  private readonly tryGetUsage = async () => {
+    try {
+      const usage = await AsyncUtils.withTimeout(
+        UsageService.instance.fetchUsage(),
+        MAX_USAGE_TIMEOUT,
+        'Usage fetch timeout',
+      );
+      return FormatUtils.humanFileSize(usage);
+    } catch {
+      return '-';
+    }
+  };
+
+  private readonly tryGetSpaceLimit = async () => {
+    try {
+      const limit = await AsyncUtils.withTimeout(
+        UsageService.instance.fetchSpaceLimit(),
+        MAX_USAGE_TIMEOUT,
+        'Space limit timeout',
+      );
+      return FormatUtils.formatLimit(limit);
+    } catch {
+      return '-';
+    }
+  };
 }
diff --git a/src/commands/webdav.ts b/src/commands/webdav.ts
@@ -3,6 +3,7 @@ import { PM2Utils } from '../utils/pm2.utils';
 import { CLIUtils } from '../utils/cli.utils';
 import { ConfigService } from '../services/config.service';
 import { AuthService } from '../services/auth.service';
+import { WebDavServer } from '../webdav/webdav-server';
 
 export default class Webdav extends Command {
   static readonly args = {
@@ -28,10 +29,14 @@ export default class Webdav extends Command {
     let message = '';
     let success = true;
     await PM2Utils.connect();
+
+    const configs = await ConfigService.instance.readWebdavConfig();
+
     switch (args.action) {
       case 'start':
       case 'enable': {
         await AuthService.instance.getAuthDetails();
+        WebDavServer.checkwebDAVCredentials(configs);
         message = await this.enableWebDav(flags['json']);
         break;
       }
@@ -44,6 +49,7 @@ export default class Webdav extends Command {
 
       case 'restart': {
         await AuthService.instance.getAuthDetails();
+        WebDavServer.checkwebDAVCredentials(configs);
         message = await this.restartWebDav(flags['json']);
         break;
       }
diff --git a/src/hooks/prerun/auth_check.ts b/src/hooks/prerun/auth_check.ts
@@ -21,9 +21,12 @@ const hook: Hook<'prerun'> = async function (opts) {
   const { Command, argv } = opts;
   const jsonFlag = argv.includes('--json');
 
+  const commandsToSkipNames = CommandsToSkip.map((command) => command.name?.toLowerCase()).filter(Boolean);
+  const commandsToSkipIds = CommandsToSkip.map((command) => command.id?.toLowerCase()).filter(Boolean);
+
   if (
-    !CommandsToSkip.map((command) => command.name.toLowerCase()).includes(Command.name.toLowerCase()) &&
-    !CommandsToSkip.map((command) => command.id.toLowerCase()).includes(Command.id.toLowerCase())
+    !commandsToSkipNames.includes(Command.name?.toLowerCase()) &&
+    !commandsToSkipIds.includes(Command.id?.toLowerCase())
   ) {
     CLIUtils.doing('Checking credentials', jsonFlag);
     try {
diff --git a/src/services/drive/drive-file.service.ts b/src/services/drive/drive-file.service.ts
@@ -8,6 +8,7 @@ import { DriveFolderService } from './drive-folder.service';
 import { NotFoundError } from '../../utils/errors.utils';
 import { PathUtils } from '../../utils/path.utils';
 import { logger } from '../../utils/logger.utils';
+import { FileStatus } from '@internxt/sdk/dist/drive/storage/types';
 
 export class DriveFileService {
   static readonly instance = new DriveFileService();
@@ -67,6 +68,9 @@ export class DriveFileService {
     const [getFileMetadata] = storageClient.getFile(uuid);
 
     const fileMetadata = await getFileMetadata;
+    if (fileMetadata?.status !== FileStatus.EXISTS) {
+      throw new NotFoundError(`File with uuid ${uuid} not found`);
+    }
     const driveFileItem = DriveUtils.driveFileMetaToItem(fileMetadata);
 
     await FileRepository.instance.createOrUpdate([driveFileItem]);
@@ -102,7 +106,7 @@ export class DriveFileService {
     const fileMeta = subFiles.find(
       (file) => (file.plainName === name || file.name === name) && (file.type ?? null) === type,
     );
-    if (!fileMeta) {
+    if (fileMeta?.status !== FileStatus.EXISTS) {
       throw new NotFoundError('File not found');
     }
     return DriveUtils.driveFileMetaToItem(fileMeta);
diff --git a/src/services/drive/drive-folder.service.ts b/src/services/drive/drive-folder.service.ts
@@ -21,7 +21,11 @@ export class DriveFolderService {
     const storageClient = SdkManager.instance.getStorage();
     const folderMeta = await storageClient.getFolderMeta(uuid);
     const folderItem = DriveUtils.driveFolderMetaToItem(folderMeta);
+    if (folderItem?.status !== FileStatus.EXISTS) {
+      throw new NotFoundError(`Folder with uuid ${uuid} not found`);
+    }
     await FolderRepository.instance.createOrUpdate([folderItem]);
+
     return folderItem;
   };
 
@@ -83,6 +87,8 @@ export class DriveFolderService {
       folders = (await personalFolderContentPromise).folders;
     }
 
+    folders = folders.filter((folder) => folder.status === FileStatus.EXISTS);
+
     await FolderRepository.instance.createOrUpdate(
       folders.map(
         (folder) =>
@@ -130,6 +136,8 @@ export class DriveFolderService {
       files = (await folderContentPromise).files;
     }
 
+    files = files.filter((file) => file.status === FileStatus.EXISTS);
+
     if (files.length > 0) {
       await FileRepository.instance.deleteByParentUuid(folderUuid);
       await FileRepository.instance.createOrUpdate(
@@ -202,7 +210,7 @@ export class DriveFolderService {
   public getByParentUuidAndName = async (parentUuid: string, name: string): Promise<DriveFolderItem> => {
     const subFolders = await this.getFolderSubfolders(parentUuid);
     const folderMeta = subFolders.find((folder) => folder.plainName === name || folder.name === name);
-    if (!folderMeta) {
+    if (folderMeta?.status !== FileStatus.EXISTS) {
       throw new NotFoundError('Folder not found');
     }
 
diff --git a/src/services/thumbnail.service.ts b/src/services/thumbnail.service.ts
@@ -6,6 +6,7 @@ import { NetworkFacade } from './network/network-facade.service';
 import { ThumbnailConfig, ThumbnailUtils } from '../utils/thumbnail.utils';
 import { BufferStream } from '../utils/stream.utils';
 import { ErrorUtils } from '../utils/errors.utils';
+import { AsyncUtils } from '../utils/async.utils';
 
 let sharpDependency: typeof import('sharp') | null = null;
 
@@ -102,19 +103,11 @@ export class ThumbnailService {
     try {
       const thumbnailBuffer = bufferStream?.getBuffer();
       if (thumbnailBuffer) {
-        let timeoutId: NodeJS.Timeout;
-        const timeoutPromise = new Promise<never>((_, reject) => {
-          timeoutId = setTimeout(() => {
-            reject(new Error('Thumbnail upload timeout'));
-          }, ThumbnailService.MAX_THUMBNAIL_TIMEOUT);
-        });
-
-        await Promise.race([
+        await AsyncUtils.withTimeout(
           ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, bucket, fileUuid, networkFacade, size),
-          timeoutPromise,
-        ]).finally(() => {
-          clearTimeout(timeoutId);
-        });
+          ThumbnailService.MAX_THUMBNAIL_TIMEOUT,
+          'Thumbnail upload timeout',
+        );
       }
     } catch (error) {
       ErrorUtils.report(error);
diff --git a/src/utils/async.utils.ts b/src/utils/async.utils.ts
@@ -8,4 +8,22 @@ export class AsyncUtils {
   static readonly sleep = (ms: number): Promise<void> => {
     return new Promise((resolve) => setTimeout(resolve, ms));
   };
+
+  static readonly withTimeout = async <T>(
+    promise: Promise<T>,
+    timeoutMs: number,
+    errorMessage = 'Operation timed out',
+  ): Promise<T> => {
+    let timeoutId: NodeJS.Timeout;
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error(errorMessage));
+      }, timeoutMs);
+    });
+
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+      clearTimeout(timeoutId);
+    }) as Promise<T>;
+  };
 }
diff --git a/src/utils/database.utils.ts b/src/utils/database.utils.ts
@@ -27,7 +27,6 @@ export class DatabaseUtils {
 
     const folder = await getByParentAndName(parentUuid, currentFolder);
 
-    // If no intermediate folder is found, return onNotFound callback
     if (!folder) {
       return;
     }
diff --git a/src/utils/drive.utils.ts b/src/utils/drive.utils.ts
@@ -1,4 +1,4 @@
-import { FileMeta, FolderMeta, CreateFolderResponse } from '@internxt/sdk/dist/drive/storage/types';
+import { FileMeta, FolderMeta, CreateFolderResponse, FileStatus } from '@internxt/sdk/dist/drive/storage/types';
 import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
 
 export class DriveUtils {
@@ -25,7 +25,7 @@ export class DriveUtils {
       itemType: 'folder',
       uuid: folderMeta.uuid,
       bucket: folderMeta.bucket,
-      status: folderMeta.deleted || folderMeta.removed ? 'TRASHED' : 'EXISTS',
+      status: folderMeta.deleted || folderMeta.removed ? FileStatus.TRASHED : FileStatus.EXISTS,
       name: folderMeta.plainName ?? folderMeta.name,
       parentUuid: folderMeta.parentUuid,
       createdAt: new Date(folderMeta.createdAt),
@@ -40,7 +40,7 @@ export class DriveUtils {
       itemType: 'folder',
       uuid: folderResponse.uuid,
       bucket: folderResponse.bucket,
-      status: folderResponse.deleted || folderResponse.removed ? 'TRASHED' : 'EXISTS',
+      status: folderResponse.deleted || folderResponse.removed ? FileStatus.TRASHED : FileStatus.EXISTS,
       name: folderResponse.plainName ?? folderResponse.name,
       parentUuid: folderResponse.parentUuid,
       createdAt: new Date(folderResponse.createdAt),
diff --git a/src/webdav/handlers/HEAD.handler.ts b/src/webdav/handlers/HEAD.handler.ts
@@ -9,34 +9,32 @@ export class HEADRequestHandler implements WebDavMethodHandler {
   handle = async (req: Request, res: Response) => {
     const resource = await WebDavUtils.getRequestedResource(req.url);
 
-    webdavLogger.info(`[HEAD] Request received for file at ${resource.url}`);
+    webdavLogger.info(`[HEAD] Request received for item at ${resource.url}`);
 
-    try {
-      const driveFile = await WebDavUtils.getDriveFileFromResource(resource.url);
+    const driveItem = await WebDavUtils.getDriveItemFromResource(resource);
 
-      if (!driveFile) {
-        throw new NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
-      }
+    if (!driveItem) {
+      throw new NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+    }
 
-      webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+    webdavLogger.info(`[HEAD] [${driveItem.uuid}] Found Drive item`);
 
+    if (driveItem.itemType === 'file') {
       const range = req.headers['range'];
       const rangeOptions = NetworkUtils.parseRangeHeader({
         range,
-        totalFileSize: driveFile.size,
+        totalFileSize: driveItem.size,
       });
-      let contentLength = driveFile.size;
+      let contentLength = driveItem.size;
       if (rangeOptions) {
-        webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+        webdavLogger.info(`[HEAD] [${driveItem.uuid}] Range request received:`, { rangeOptions });
         contentLength = rangeOptions.rangeSize;
       }
 
       res.header('Content-Type', 'application/octet-stream');
       res.header('Content-length', contentLength.toString());
-      res.status(200).send();
-    } catch {
-      res.header('Content-Type', 'application/octet-stream');
-      res.status(200).send();
     }
+
+    res.status(200).send();
   };
 }
diff --git a/src/webdav/webdav-server.ts b/src/webdav/webdav-server.ts
@@ -59,8 +59,22 @@ export class WebDavServer {
     this.app.copy(serverListenPath, asyncHandler(new COPYRequestHandler().handle));
   };
 
+  public static readonly checkwebDAVCredentials = (configs: WebdavConfig) => {
+    if (configs.customAuth) {
+      if (!configs.username?.trim()) {
+        throw new Error('WebDAV CustomAuth is enabled but no username was provided.');
+      }
+
+      if (!configs.password?.trim()) {
+        throw new Error('WebDAV CustomAuth is enabled but no password was provided.');
+      }
+    }
+  };
+
   start = async () => {
     const configs = await ConfigService.instance.readWebdavConfig();
+    WebDavServer.checkwebDAVCredentials(configs);
+
     this.app.disable('x-powered-by');
     this.registerStartMiddlewares(configs);
     this.registerHandlers();
diff --git a/test/webdav/handlers/DELETE.handler.test.ts b/test/webdav/handlers/DELETE.handler.test.ts
@@ -6,6 +6,7 @@ import {
   createWebDavResponseFixture,
   getRequestedFileResource,
   getRequestedFolderResource,
+  getWebdavConfigMock,
 } from '../../fixtures/webdav.fixture';
 import { TrashService } from '../../../src/services/drive/trash.service';
 import { NotFoundError } from '../../../src/utils/errors.utils';
@@ -14,10 +15,12 @@ import { newFileItem, newFolderItem } from '../../fixtures/drive.fixture';
 import { WebDavRequestedResource } from '../../../src/types/webdav.types';
 import { AuthService } from '../../../src/services/auth.service';
 import { UserCredentialsFixture } from '../../fixtures/login.fixture';
+import { ConfigService } from '../../../src/services/config.service';
 
 describe('DELETE request handler', () => {
   beforeEach(() => {
     vi.spyOn(AuthService.instance, 'getAuthDetails').mockResolvedValue(UserCredentialsFixture);
+    vi.spyOn(ConfigService.instance, 'readWebdavConfig').mockResolvedValue(getWebdavConfigMock());
   });
 
   it('When the item does not exist, it should reply with a 404 error', async () => {
@@ -32,7 +35,6 @@ describe('DELETE request handler', () => {
     const response = createWebDavResponseFixture({
       status: vi.fn().mockReturnValue({ send: vi.fn() }),
     });
-
     const getRequestedResourceStub = vi
       .spyOn(WebDavUtils, 'getRequestedResource')
       .mockResolvedValue(requestedFileResource);
diff --git a/test/webdav/handlers/HEAD.handler.test.ts b/test/webdav/handlers/HEAD.handler.test.ts
@@ -8,9 +8,10 @@ import {
 } from '../../fixtures/webdav.fixture';
 import { DriveFileService } from '../../../src/services/drive/drive-file.service';
 import { WebDavRequestedResource } from '../../../src/types/webdav.types';
-import { newFileItem } from '../../fixtures/drive.fixture';
+import { newFileItem, newFolderItem } from '../../fixtures/drive.fixture';
 import { WebDavUtils } from '../../../src/utils/webdav.utils';
 import { randomInt } from 'crypto';
+import { DriveFolderService } from '../../../src/services/drive/drive-folder.service';
 
 describe('HEAD request handler', () => {
   let sut: HEADRequestHandler;
@@ -30,8 +31,20 @@ describe('HEAD request handler', () => {
       status: vi.fn().mockReturnValue({ send: vi.fn() }),
     });
 
+    const mockFolder = newFolderItem();
+
+    vi.spyOn(DriveFileService.instance, 'getFileMetadataByPath').mockRejectedValue(undefined);
+    const getRequestedResourceStub = vi
+      .spyOn(WebDavUtils, 'getRequestedResource')
+      .mockResolvedValue(requestedFolderResource);
+    const getFolderMetadataStub = vi
+      .spyOn(DriveFolderService.instance, 'getFolderMetadataByPath')
+      .mockResolvedValue(mockFolder);
+
     await sut.handle(request, response);
     expect(response.status).toHaveBeenCalledWith(200);
+    expect(getRequestedResourceStub).toHaveBeenCalledOnce();
+    expect(getFolderMetadataStub).toHaveBeenCalledOnce();
   });
 
   it('When a file is requested, it should reply with a 200 with the correct headers', async () => {

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,6 @@ export class DatabaseUtils {`
`27`	`27`
`28`	`28`	`const folder = await getByParentAndName(parentUuid, currentFolder);`
`29`	`29`
`30`		`- // If no intermediate folder is found, return onNotFound callback`
`31`	`30`	`if (!folder) {`
`32`	`31`	`return;`
`33`	`32`	`}`