[PB-3399]: fix/improve-and-fix-webdav-auth-management

src/commands/webdav.ts

@@ -4,6 +4,7 @@ import { CLIUtils } from '../utils/cli.utils';
 import { ConfigService } from '../services/config.service';
 import { DriveDatabaseManager } from '../services/database/drive-database-manager.service';
 import { ErrorUtils } from '../utils/errors.utils';
+import { AuthService } from '../services/auth.service';
 
 export default class Webdav extends Command {
   static readonly args = {
@@ -31,6 +32,7 @@ export default class Webdav extends Command {
     await PM2Utils.connect();
     switch (args.action) {
       case 'enable': {
+        await AuthService.instance.getAuthDetails();
         message = await this.enableWebDav();
         break;
       }
@@ -41,6 +43,7 @@ export default class Webdav extends Command {
       }
 
       case 'restart': {
+        await AuthService.instance.getAuthDetails();
         message = await this.restartWebDav();
         break;
       }

src/services/auth.service.ts

@@ -77,7 +77,7 @@ export class AuthService {
   };
 
   /**
-   * Obtains the user auth details
+   * Checks and returns the user auth details (it refreshes the tokens if needed)
    *
    * @returns The user details and the auth tokens
    */

src/webdav/index.ts

@@ -13,6 +13,7 @@ import { AuthService } from '../services/auth.service';
 import { CryptoService } from '../services/crypto.service';
 import { TrashService } from '../services/drive/trash.service';
 import { webdavLogger } from '../utils/logger.utils';
+import { SdkManager } from '../services/sdk-manager.service';
 
 dotenv.config();
 
@@ -23,6 +24,12 @@ const init = async () => {
 
   await DriveDatabaseManager.init();
 
+  const { token, newToken } = await AuthService.instance.getAuthDetails();
+  SdkManager.init({
+    token,
+    newToken,
+  });
+
   new WebDavServer(
     express(),
     ConfigService.instance,

src/webdav/middewares/auth.middleware.ts

@@ -1,23 +1,24 @@
 import { RequestHandler } from 'express';
-import { ConfigService } from '../../services/config.service';
 import { SdkManager } from '../../services/sdk-manager.service';
+import { AuthService } from '../../services/auth.service';
+import { webdavLogger } from '../../utils/logger.utils';
 
-export const AuthMiddleware = (configService: ConfigService): RequestHandler => {
+export const AuthMiddleware = (authService: AuthService): RequestHandler => {
   return (req, res, next) => {
     (async () => {
       try {
-        const credentials = await configService.readUser();
-        if (!credentials) throw new Error('Unauthorized');
+        const { token, newToken, user } = await authService.getAuthDetails();
         SdkManager.init({
-          token: credentials.token,
-          newToken: credentials.newToken,
+          token,
+          newToken,
         });
         req.user = {
-          uuid: credentials.user.uuid,
-          rootFolderId: credentials.user.root_folder_id,
+          uuid: user.uuid,
+          rootFolderId: user.root_folder_id,
         };
         next();
       } catch (error) {
+        webdavLogger.error('Error from AuthMiddleware: ' + (error as Error).message);
         res.status(401).send({ error: (error as Error).message });
       }
     })();

src/webdav/webdav-server.ts

@@ -59,7 +59,7 @@ export class WebDavServer {
   private readonly registerMiddlewares = async () => {
     this.app.use(bodyParser.text({ type: ['application/xml', 'text/xml'] }));
     this.app.use(ErrorHandlingMiddleware);
-    this.app.use(AuthMiddleware(ConfigService.instance));
+    this.app.use(AuthMiddleware(AuthService.instance));
     this.app.use(
       RequestLoggerMiddleware({
         enable: true,

test/webdav/middlewares/auth.middleware.test.ts

@@ -1,8 +1,9 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { AuthMiddleware } from '../../../src/webdav/middewares/auth.middleware';
 import { createWebDavRequestFixture, createWebDavResponseFixture } from '../../fixtures/webdav.fixture';
-import { ConfigService } from '../../../src/services/config.service';
 import { UserCredentialsFixture } from '../../fixtures/login.fixture';
+import { AuthService } from '../../../src/services/auth.service';
+import { MissingCredentialsError } from '../../../src/types/command.types';
 
 describe('Auth middleware', () => {
   beforeEach(() => {
@@ -18,14 +19,16 @@ describe('Auth middleware', () => {
     });
     const next = vi.fn();
 
-    const configServiceStub = vi.spyOn(ConfigService.instance, 'readUser').mockResolvedValue(undefined);
+    const authServiceStub = vi
+      .spyOn(AuthService.instance, 'getAuthDetails')
+      .mockRejectedValue(new MissingCredentialsError());
 
-    await AuthMiddleware(ConfigService.instance)(req, res, next);
+    await AuthMiddleware(AuthService.instance)(req, res, next);
 
-    expect(configServiceStub).toHaveBeenCalledOnce();
+    expect(authServiceStub).toHaveBeenCalledOnce();
     expect(next).not.toHaveBeenCalled();
     expect(res.status).toHaveBeenCalledWith(401);
-    expect(res.send).toHaveBeenCalledWith({ error: 'Unauthorized' });
+    expect(res.send).toHaveBeenCalledWith({ error: new MissingCredentialsError().message });
   });
 
   it('When the user is authenticated, then it should add the user to the request', async () => {
@@ -34,13 +37,13 @@ describe('Auth middleware', () => {
     });
     const res = createWebDavResponseFixture({});
     const next = vi.fn();
-    const configServiceStub = vi.spyOn(ConfigService.instance, 'readUser').mockResolvedValue(UserCredentialsFixture);
+    const authServiceStub = vi.spyOn(AuthService.instance, 'getAuthDetails').mockResolvedValue(UserCredentialsFixture);
 
-    await AuthMiddleware(ConfigService.instance)(req, res, next);
+    await AuthMiddleware(AuthService.instance)(req, res, next);
 
     // @ts-expect-error - User is added to the request, but TS is not picking it as we specified null before
     expect(req.user.rootFolderId).to.be.equal(UserCredentialsFixture.user.root_folder_id);
-    expect(configServiceStub).toHaveBeenCalledOnce();
+    expect(authServiceStub).toHaveBeenCalledOnce();
     expect(next).toHaveBeenCalledOnce();
     expect(res.status).not.toHaveBeenCalled();
     expect(res.send).not.toHaveBeenCalled();