feat(nautilus-extension): implement sharing link generation and domain fetching

Author: egalvis27

scripts/tsc-max-errors.sh

@@ -3,7 +3,7 @@
 # Maximum allowed TypeScript errors (current baseline)
 # TODO: Decrease this number as errors are fixed, never increase it
 # Note: CI environment may have different error count than local due to dependency differences
-MAX_ERRORS=150
+MAX_ERRORS=146
 
 # Run TypeScript compiler and capture output
 OUTPUT=$(tsc --noEmit --pretty --skipLibCheck 2>&1)

src/__mocks__/electron.ts

@@ -55,4 +55,14 @@ const clipboard = {
   writeText: vi.fn(),
 };
 
-export { app, ipcMain, ipcRenderer, dialog, BrowserWindow, safeStorage, nativeImage, shell, clipboard };
+class Notification {
+  static show = vi.fn();
+
+  constructor(_options: { title: string; body: string }) {}
+
+  show() {
+    Notification.show();
+  }
+}
+
+export { app, ipcMain, ipcRenderer, dialog, BrowserWindow, safeStorage, nativeImage, shell, clipboard, Notification };

src/apps/drive/hydration-api/controllers/contents.test.ts

@@ -0,0 +1,215 @@
+import { Container } from 'diod';
+import { NextFunction, Request, Response } from 'express';
+import { mockDeep } from 'vitest-mock-extended';
+import { call } from 'tests/vitest/utils.helper';
+import { buildContentsController } from './contents';
+import { StorageFileDeleter } from '../../../../context/storage/StorageFiles/application/delete/StorageFileDeleter';
+import { AllFilesInFolderAreAvailableOffline } from '../../../../context/storage/StorageFolders/application/offline/AllFilesInFolderAreAvailableOffline';
+import { MakeStorageFileAvaliableOffline } from '../../../../context/storage/StorageFiles/application/offline/MakeStorageFileAvaliableOffline';
+import { StorageFileIsAvailableOffline } from '../../../../context/storage/StorageFiles/application/offline/StorageFileIsAvailableOffline';
+import { MakeFolderAvaliableOffline } from '../../../../context/storage/StorageFolders/application/offline/MakeFolderAvaliableOffline';
+import { StorageFolderDeleter } from '../../../../context/storage/StorageFolders/application/delete/StorageFolderDeleter';
+import * as generateLinkModule from '../../../../backend/features/nautilus-extension/create-sharing-link/generate-link';
+
+describe('contents', () => {
+  const generateLinkMock = vi.spyOn(generateLinkModule, 'generateLink');
+
+  let req: ReturnType<typeof mockDeep<Request>>;
+  let res: ReturnType<typeof mockDeep<Response>>;
+  let next: NextFunction;
+
+  const storageFileIsAvailableRun = vi.fn();
+  const allFilesInFolderAreAvailableRun = vi.fn();
+  const storageFileDeleterRun = vi.fn();
+  const makeStorageFileAvaliableOfflineRun = vi.fn();
+  const makeFolderAvaliableOfflineRun = vi.fn();
+  const storageFolderDeleterRun = vi.fn();
+
+  function createContainer() {
+    const services = new Map<unknown, { run: (...args: unknown[]) => unknown }>([
+      [StorageFileIsAvailableOffline, { run: storageFileIsAvailableRun }],
+      [AllFilesInFolderAreAvailableOffline, { run: allFilesInFolderAreAvailableRun }],
+      [StorageFileDeleter, { run: storageFileDeleterRun }],
+      [MakeStorageFileAvaliableOffline, { run: makeStorageFileAvaliableOfflineRun }],
+      [MakeFolderAvaliableOffline, { run: makeFolderAvaliableOfflineRun }],
+      [StorageFolderDeleter, { run: storageFolderDeleterRun }],
+    ]);
+
+    return {
+      get: vi.fn((token: unknown) => {
+        const service = services.get(token);
+
+        if (!service) throw new Error('Service not mocked');
+
+        return service;
+      }),
+    } as unknown as Container;
+  }
+
+  function encodePath(path: string) {
+    return Buffer.from(path, 'utf-8').toString('base64');
+  }
+
+  beforeEach(() => {
+    req = mockDeep<Request>();
+    res = mockDeep<Response>();
+    next = vi.fn((error?: unknown) => error) as unknown as NextFunction;
+
+    req.params = { path: encodePath('/folder/file.txt') };
+
+    res.status.mockReturnValue(res);
+    res.json.mockReturnValue(res);
+
+    storageFileIsAvailableRun.mockResolvedValue(false);
+    allFilesInFolderAreAvailableRun.mockResolvedValue(false);
+    storageFileDeleterRun.mockResolvedValue(undefined);
+    makeStorageFileAvaliableOfflineRun.mockResolvedValue(undefined);
+    makeFolderAvaliableOfflineRun.mockResolvedValue(undefined);
+    storageFolderDeleterRun.mockResolvedValue(undefined);
+    generateLinkMock.mockResolvedValue('https://link.test');
+  });
+
+  it('should return generated link in copyLink', async () => {
+    req.params.path = encodePath('/folder/my%20file.txt');
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.copyLink(req, res, next);
+
+    call(generateLinkMock).toStrictEqual({ path: '/folder/my file.txt' });
+    call(res.status).toBe(202);
+    call(res.json).toStrictEqual({ path: '/folder/my file.txt', link: 'https://link.test' });
+  });
+
+  it('should call next when copyLink fails', async () => {
+    const error = new Error('copy failed');
+    generateLinkMock.mockRejectedValue(error);
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.copyLink(req, res, next);
+
+    call(next).toBe(error);
+  });
+
+  it('should resolve file availability in get', async () => {
+    storageFileIsAvailableRun.mockResolvedValue(true);
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.get(req, res);
+
+    call(res.json).toStrictEqual({ locallyAvaliable: true });
+  });
+
+  it('should fallback to folder availability in get when file lookup fails', async () => {
+    storageFileIsAvailableRun.mockRejectedValue(new Error('not a file'));
+    allFilesInFolderAreAvailableRun.mockResolvedValue(true);
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.get(req, res);
+
+    call(res.json).toStrictEqual({ locallyAvaliable: true });
+  });
+
+  it('should return false in getFile when file lookup fails', async () => {
+    storageFileIsAvailableRun.mockRejectedValue(new Error('not found'));
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.getFile(req, res);
+
+    call(res.json).toStrictEqual({ locallyAvaliable: false });
+  });
+
+  it('should return false in getFolder when folder lookup fails', async () => {
+    allFilesInFolderAreAvailableRun.mockRejectedValue(new Error('not found'));
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.getFolder(req, res);
+
+    call(res.json).toStrictEqual({ locallyAvaliable: false });
+  });
+
+  it('should remove file and return 201', async () => {
+    req.params.path = encodePath('/folder/to-delete.txt');
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.removeFile(req, res);
+
+    call(storageFileDeleterRun).toBe('/folder/to-delete.txt');
+    call(res.status).toBe(201);
+    expect(res.send).toHaveBeenCalled();
+  });
+
+  it('should download file and return 202', async () => {
+    req.params.path = encodePath('/folder/to-download.txt');
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.downloadFile(req, res, next);
+
+    call(makeStorageFileAvaliableOfflineRun).toBe('/folder/to-download.txt');
+    call(res.status).toBe(202);
+    expect(res.send).toHaveBeenCalled();
+  });
+
+  it('should call next when downloadFile fails', async () => {
+    const error = new Error('download file failed');
+
+    const container = {
+      get: vi.fn(() => {
+        throw error;
+      }),
+    } as unknown as Container;
+
+    const controller = buildContentsController(container);
+
+    await controller.downloadFile(req, res, next);
+
+    call(next).toBe(error);
+  });
+
+  it('should remove folder and return 201', async () => {
+    req.params.path = encodePath('/folder/to-delete');
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.removeFolder(req, res);
+
+    call(storageFolderDeleterRun).toBe('/folder/to-delete');
+    call(res.status).toBe(201);
+    expect(res.send).toHaveBeenCalled();
+  });
+
+  it('should download folder and return 202', async () => {
+    req.params.path = encodePath('/folder/to-download');
+
+    const controller = buildContentsController(createContainer());
+
+    await controller.downloadFolder(req, res, next);
+
+    call(makeFolderAvaliableOfflineRun).toBe('/folder/to-download');
+    call(res.status).toBe(202);
+    expect(res.send).toHaveBeenCalled();
+  });
+
+  it('should call next when downloadFolder fails', async () => {
+    const error = new Error('download folder failed');
+
+    const container = {
+      get: vi.fn(() => {
+        throw error;
+      }),
+    } as unknown as Container;
+
+    const controller = buildContentsController(container);
+
+    await controller.downloadFolder(req, res, next);
+
+    call(next).toBe(error);
+  });
+});

src/apps/drive/hydration-api/controllers/contents.ts

@@ -8,7 +8,7 @@ import { StorageFileIsAvailableOffline } from '../../../../context/storage/Stora
 import { Optional } from '../../../../shared/types/Optional';
 import { MakeFolderAvaliableOffline } from '../../../../context/storage/StorageFolders/application/offline/MakeFolderAvaliableOffline';
 import { StorageFolderDeleter } from '../../../../context/storage/StorageFolders/application/delete/StorageFolderDeleter';
-import { generateLink } from '../../../main/nautilus-extension/create-sharing-link/generate-link';
+import { generateLink } from '../../../../backend/features/nautilus-extension/create-sharing-link/generate-link';
 
 export function buildContentsController(container: Container) {
   async function isFileLocallyAvailable(path: string): Promise<Optional<boolean>> {
@@ -142,7 +142,7 @@ export function buildContentsController(container: Container) {
     }
   };
 
-  const copyLink = async (req: Request, res: Response, next: NextFunction) => {
+  async function copyLink(req: Request, res: Response, next: NextFunction) {
     try {
       const decodedBuffer = Buffer.from(req.params.path, 'base64');
 
@@ -155,7 +155,7 @@ export function buildContentsController(container: Container) {
       next(error);
       return;
     }
-  };
+  }
 
   return {
     copyLink,

src/apps/main/nautilus-extension/create-sharing-link/fetch-random-domain.ts

@@ -0,0 +1,60 @@
+import { DriveServerError } from '../../../../infra/drive-server/drive-server.error';
+import * as createSharingModule from '../../../../infra/drive-server/services/sharings/services/create-sharing';
+import { createSharingResult } from './create-sharing-result';
+import { call, partialSpyOn } from 'tests/vitest/utils.helper';
+
+describe('create-sharing-result', () => {
+  const createSharingMock = partialSpyOn(createSharingModule, 'createSharing');
+
+  beforeEach(() => {
+    createSharingMock.mockResolvedValue({
+      data: {
+        encryptedCode: 'server-encrypted-code',
+        id: 'sharing-id',
+      },
+    } as object);
+  });
+
+  it('should call createSharing with expected payload and return sharing data', async () => {
+    const result = await createSharingResult({
+      encryptedCode: 'local-encrypted-code',
+      encryptionKey: 'encrypted-mnemonic',
+      item: {
+        itemId: 'file-uuid',
+        itemType: 'file',
+      },
+    });
+
+    call(createSharingMock).toStrictEqual({
+      body: {
+        encryptedCode: 'local-encrypted-code',
+        encryptedPassword: null,
+        encryptionAlgorithm: 'inxt-v2',
+        encryptionKey: 'encrypted-mnemonic',
+        itemId: 'file-uuid',
+        itemType: 'file',
+        persistPreviousSharing: true,
+      },
+    });
+
+    expect(result).toStrictEqual({
+      encryptedCode: 'server-encrypted-code',
+      id: 'sharing-id',
+    });
+  });
+
+  it('should throw transformed error when createSharing returns error', async () => {
+    createSharingMock.mockResolvedValue({ error: new DriveServerError('NOT_FOUND', 404, 'not found') } as object);
+
+    await expect(
+      createSharingResult({
+        encryptedCode: 'local-encrypted-code',
+        encryptionKey: 'encrypted-mnemonic',
+        item: {
+          itemId: 'folder-uuid',
+          itemType: 'folder',
+        },
+      }),
+    ).rejects.toThrow('Error while creating sharing: not found');
+  });
+});