feat: add sharing link functionality for drive files and update Nautilus extension

Author: egalvis27

assets/python-nautilus/internxt-virtual-drive.py

@@ -162,13 +162,13 @@ def _create_menu_items(self, files, group):
 
           active_items.append(clear)
 
-        if len(remote_files) > 0:
-          download = Nautilus.MenuItem(
-                name="InternxtVirtualDrive::DOWNLOAD" + group,
-                label="Make Available Offline",
+        if len(files) == 1 and len(remote_files) == 1:
+          copy_link = Nautilus.MenuItem(
+                name="InternxtVirtualDrive::COPY_LINK" + group,
+                label="Copy Internxt Link",
             )
-          download.connect("activate", self._make_locally_available, remote_files)
-          active_items.append(download)
+          copy_link.connect("activate", self._copy_internxt_link, remote_files)
+          active_items.append(copy_link)
 
         return active_items
 
@@ -199,6 +199,31 @@ def _make_locally_available(self, menu, files):
             # if (response.status_code == 202):
             #   self._setItemStatus(file, 'on_local')
 
+    def _copy_internxt_link(self, menu, files):
+      base64_encoded = self._encode_file_path(files[0])
+
+      url = base_url + 'copy-link/' + base64_encoded
+
+      try:
+        response = requests.post(url)
+
+        if response.status_code != 202:
+          print(response.status_code)
+          print(response.text)
+          return
+
+        data = response.json()
+        link = data.get('link')
+
+        if not link:
+          print('Copy link failed: missing link in response')
+          return
+
+        self.display.get_clipboard().set(link)
+        print('link copied')
+      except Exception as error:
+        print('Copy link failed:', error)
+
     def _make_remote_only(self, menu, files):
         for file in files:
             self._setItemStatus(file, 'removing')

src/__mocks__/electron.ts

@@ -51,4 +51,8 @@ const shell = {
   openExternal: vi.fn(),
 };
 
-export { app, ipcMain, ipcRenderer, dialog, BrowserWindow, safeStorage, nativeImage, shell };
+const clipboard = {
+  writeText: vi.fn(),
+};
+
+export { app, ipcMain, ipcRenderer, dialog, BrowserWindow, safeStorage, nativeImage, shell, clipboard };

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

@@ -8,6 +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';
 
 export function buildContentsController(container: Container) {
   async function isFileLocallyAvailable(path: string): Promise<Optional<boolean>> {
@@ -141,7 +142,23 @@ export function buildContentsController(container: Container) {
     }
   };
 
+  const copyLink = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const decodedBuffer = Buffer.from(req.params.path, 'base64');
+
+      const path = decodedBuffer.toString('utf-8').replaceAll('%20', ' ');
+
+      const link = await generateLink({ path });
+
+      res.status(202).json({ path, link });
+    } catch (error) {
+      next(error);
+      return;
+    }
+  };
+
   return {
+    copyLink,
     downloadFile,
     removeFile,
     get,

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

@@ -18,5 +18,8 @@ export function buildHydrationRouter(container: Container): Router {
   router.delete('/files/:path', controllers.removeFile);
   router.post('/files/:path', controllers.downloadFile);
 
+  // link
+  router.post('/copy-link/:path', controllers.copyLink);
+
   return router;
 }

src/apps/main/nautilus-extension/create-sharing-link/create-sharing-result.ts

@@ -0,0 +1,32 @@
+import { createSharing } from '../../../../infra/drive-server/services/sharings/services/create-sharing';
+import { CreateSharingPayload, ShareableItem, SharingResponse } from './types';
+import { toError } from './to-error';
+
+type Props = {
+  encryptedCode: string;
+  encryptionKey: string;
+  item: ShareableItem;
+};
+
+export async function createSharingResult({ encryptedCode, encryptionKey, item }: Props) {
+  const payload: CreateSharingPayload = {
+    encryptedCode,
+    encryptedPassword: null,
+    encryptionAlgorithm: 'inxt-v2',
+    encryptionKey,
+    itemId: item.itemId,
+    itemType: item.itemType,
+    persistPreviousSharing: true,
+  };
+
+  const result = await createSharing({ body: payload });
+
+  if (result.error) {
+    throw toError({
+      context: 'Error while creating sharing',
+      error: result.error,
+    });
+  }
+
+  return result.data as SharingResponse;
+}

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

@@ -0,0 +1,32 @@
+import { fetchPublicSharingDomains } from '../../../../infra/drive-server/services/sharings/services/fetch-public-sharing-domains';
+import { ShareDomainsResponse } from './types';
+import { toError } from './to-error';
+
+export async function fetchRandomDomain() {
+  const result = await fetchPublicSharingDomains();
+
+  if (result.error) {
+    throw toError({
+      context: 'Error while fetching public sharing domains',
+      error: result.error,
+    });
+  }
+
+  const domains = getDomains(result.data);
+
+  if (domains.length === 0) {
+    throw new Error('No share domains available');
+  }
+
+  const randomIndex = Math.floor(Math.random() * domains.length);
+
+  return domains[randomIndex].replace(/\/$/, '');
+}
+
+function getDomains(data: ShareDomainsResponse | string[]) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+
+  return data.list;
+}

src/apps/main/nautilus-extension/create-sharing-link/generate-link.test.ts

@@ -0,0 +1,107 @@
+import { aes, stringUtils } from '@internxt/lib';
+import { logger } from '@internxt/drive-desktop-core/build/backend';
+import { validateMnemonic } from 'bip39';
+import { clipboard } from 'electron';
+import { DriveServerError } from '../../../../infra/drive-server/drive-server.error';
+import * as fetchFileMetaByPathModule from '../../../../infra/drive-server/services/files/services/fetch-file-meta-by-path';
+import * as fetchFolderMetaByPathModule from '../../../../infra/drive-server/services/folder/services/fetch-folder-meta-by-path';
+import * as createSharingModule from '../../../../infra/drive-server/services/sharings/services/create-sharing';
+import * as fetchPublicSharingDomainsModule from '../../../../infra/drive-server/services/sharings/services/fetch-public-sharing-domains';
+import * as getCredentialsModule from '../../auth/get-credentials';
+import { generateLink } from './generate-link';
+import { call, calls, partialSpyOn } from 'tests/vitest/utils.helper';
+
+vi.mock('bip39', () => ({
+  validateMnemonic: vi.fn(),
+}));
+
+describe('generate-link', () => {
+  const getCredentialsMock = partialSpyOn(getCredentialsModule, 'getCredentials');
+  const fetchFileMetaByPathMock = partialSpyOn(fetchFileMetaByPathModule, 'fetchFileMetaByPath');
+  const fetchFolderMetaByPathMock = partialSpyOn(fetchFolderMetaByPathModule, 'fetchFolderMetaByPath');
+  const fetchPublicSharingDomainsMock = partialSpyOn(fetchPublicSharingDomainsModule, 'fetchPublicSharingDomains');
+  const createSharingMock = partialSpyOn(createSharingModule, 'createSharing');
+  const loggerDebugMock = partialSpyOn(logger, 'debug');
+  const clipboardWriteTextMock = partialSpyOn(clipboard, 'writeText');
+
+  const validateMnemonicMock = vi.mocked(validateMnemonic);
+  const encryptMock = partialSpyOn(aes, 'encrypt');
+  const decryptMock = partialSpyOn(aes, 'decrypt');
+  const generateRandomStringUrlSafeMock = partialSpyOn(stringUtils, 'generateRandomStringUrlSafe');
+  const encodeV4UuidMock = partialSpyOn(stringUtils, 'encodeV4Uuid');
+
+  beforeEach(() => {
+    getCredentialsMock.mockReturnValue({ newToken: 'token', mnemonic: 'valid mnemonic' });
+    validateMnemonicMock.mockReturnValue(true);
+    generateRandomStringUrlSafeMock.mockReturnValue('plain-code');
+    encryptMock
+      .mockReturnValueOnce('encrypted-mnemonic')
+      .mockReturnValueOnce('encrypted-code');
+    decryptMock.mockReturnValue('recovered-code');
+    encodeV4UuidMock.mockReturnValue('encoded-sharing-id');
+  });
+
+  it('should create a public sharing link for a file path and copy it to clipboard', async () => {
+    fetchFileMetaByPathMock.mockResolvedValueOnce({ data: { uuid: 'file-uuid' } } as object);
+    fetchPublicSharingDomainsMock.mockResolvedValueOnce({ data: { list: ['https://share.internxt.test'] } } as object);
+    createSharingMock.mockResolvedValueOnce({
+      data: {
+        encryptedCode: 'server-encrypted-code',
+        id: '08dfcc54-16d6-4f9d-9124-8a36b12e07dd',
+      },
+    } as object);
+
+    const result = await generateLink({ path: '/folder/file.txt' });
+
+    expect(result).toBe('https://share.internxt.test/sh/file/encoded-sharing-id/recovered-code');
+    call(fetchFileMetaByPathMock).toStrictEqual({ path: '/folder/file.txt' });
+    call(fetchPublicSharingDomainsMock).toStrictEqual([]);
+    call(createSharingMock).toStrictEqual({
+      body: {
+        encryptedCode: 'encrypted-code',
+        encryptedPassword: null,
+        encryptionAlgorithm: 'inxt-v2',
+        encryptionKey: 'encrypted-mnemonic',
+        itemId: 'file-uuid',
+        itemType: 'file',
+        persistPreviousSharing: true,
+      },
+    });
+    call(clipboardWriteTextMock).toBe('https://share.internxt.test/sh/file/encoded-sharing-id/recovered-code');
+    call(loggerDebugMock).toMatchObject({
+      msg: 'link copied',
+      itemType: 'file',
+      path: '/folder/file.txt',
+    });
+  });
+
+  it('should fallback to folder metadata when file metadata is not found', async () => {
+    fetchFileMetaByPathMock.mockResolvedValueOnce({ error: new DriveServerError('NOT_FOUND', 404) } as object);
+    fetchFolderMetaByPathMock.mockResolvedValueOnce({ data: { uuid: 'folder-uuid' } } as object);
+    fetchPublicSharingDomainsMock.mockResolvedValueOnce({ data: ['https://share.internxt.test'] } as object);
+    createSharingMock.mockResolvedValueOnce({
+      data: {
+        encryptedCode: 'server-encrypted-code',
+        id: '08dfcc54-16d6-4f9d-9124-8a36b12e07dd',
+      },
+    } as object);
+
+    const result = await generateLink({ path: '/folder' });
+
+    expect(result).toBe('https://share.internxt.test/sh/folder/encoded-sharing-id/recovered-code');
+    call(fetchFileMetaByPathMock).toStrictEqual({ path: '/folder' });
+    call(fetchFolderMetaByPathMock).toStrictEqual({ path: '/folder' });
+  });
+
+  it('should fail before any network call when mnemonic is invalid', async () => {
+    validateMnemonicMock.mockReturnValue(false);
+
+    await expect(generateLink({ path: '/folder/file.txt' })).rejects.toThrow('The user mnemonic is invalid');
+
+    calls(fetchFileMetaByPathMock).toHaveLength(0);
+    calls(fetchFolderMetaByPathMock).toHaveLength(0);
+    calls(fetchPublicSharingDomainsMock).toHaveLength(0);
+    calls(createSharingMock).toHaveLength(0);
+    calls(clipboardWriteTextMock).toHaveLength(0);
+  });
+});

src/apps/main/nautilus-extension/create-sharing-link/generate-link.ts

@@ -0,0 +1,42 @@
+import { aes, stringUtils } from '@internxt/lib';
+import { logger } from '@internxt/drive-desktop-core/build/backend';
+import { validateMnemonic } from 'bip39';
+import { clipboard } from 'electron';
+import { getCredentials } from '../../auth/get-credentials';
+import { createSharingResult } from './create-sharing-result';
+import { fetchRandomDomain } from './fetch-random-domain';
+import { resolveShareableItem } from './resolve-shareable-item';
+
+export type Props = { path: string };
+
+export async function generateLink({ path }: Props) {
+  const { mnemonic } = getCredentials();
+
+  if (!validateMnemonic(mnemonic)) {
+    throw new Error('The user mnemonic is invalid');
+  }
+
+  const item = await resolveShareableItem({ path });
+  const domain = await fetchRandomDomain();
+  const plainCode = stringUtils.generateRandomStringUrlSafe(8);
+  const encryptionKey = aes.encrypt(mnemonic, plainCode);
+  const encryptedCode = aes.encrypt(plainCode, mnemonic);
+  const sharing = await createSharingResult({
+    encryptedCode,
+    encryptionKey,
+    item,
+  });
+  const recoveredCode = aes.decrypt(sharing.encryptedCode, mnemonic);
+  const sharingId = stringUtils.encodeV4Uuid(sharing.id);
+  const shareLink = `${domain}/sh/${item.itemType}/${sharingId}/${recoveredCode}`;
+
+  clipboard.writeText(shareLink);
+
+  logger.debug({
+    msg: 'link copied',
+    itemType: item.itemType,
+    path,
+  });
+
+  return shareLink;
+}

src/apps/main/nautilus-extension/create-sharing-link/resolve-shareable-item.ts

@@ -0,0 +1,68 @@
+import { fetchFileMetaByPath } from '../../../../infra/drive-server/services/files/services/fetch-file-meta-by-path';
+import { fetchFolderMetaByPath } from '../../../../infra/drive-server/services/folder/services/fetch-folder-meta-by-path';
+import { ShareableItem } from './types';
+import { toError } from './to-error';
+
+type Props = {
+  path: string;
+};
+
+export async function resolveShareableItem({ path }: Props) {
+  const candidatePaths = Array.from(new Set([path, path.startsWith('/') ? path.slice(1) : `/${path}`].filter(Boolean)));
+
+  for (const candidatePath of candidatePaths) {
+    const fileMeta = await tryGetFileMeta({ path: candidatePath });
+
+    if (fileMeta) {
+      return {
+        itemId: fileMeta.uuid,
+        itemType: 'file',
+      } satisfies ShareableItem;
+    }
+
+    const folderMeta = await tryGetFolderMeta({ path: candidatePath });
+
+    if (folderMeta) {
+      return {
+        itemId: folderMeta.uuid,
+        itemType: 'folder',
+      } satisfies ShareableItem;
+    }
+  }
+
+  throw new Error(`No Internxt item metadata found for path: ${path}`);
+}
+
+async function tryGetFileMeta({ path }: { path: string }) {
+  const result = await fetchFileMetaByPath({ path });
+
+  if (result.error) {
+    if (result.error.cause === 'NOT_FOUND') {
+      return null;
+    }
+
+    throw toError({
+      context: 'Error while fetching file metadata by path',
+      error: result.error,
+    });
+  }
+
+  return result.data;
+}
+
+async function tryGetFolderMeta({ path }: { path: string }) {
+  const result = await fetchFolderMetaByPath({ path });
+
+  if (result.error) {
+    if (result.error.cause === 'NOT_FOUND') {
+      return null;
+    }
+
+    throw toError({
+      context: 'Error while fetching folder metadata by path',
+      error: result.error,
+    });
+  }
+
+  return result.data;
+}