feat: Refactor device management functions to use Result type for error handling

Author: egalvis27

src/apps/main/background-processes/backups/BackupConfiguration/BackupConfiguration.ts

@@ -33,7 +33,8 @@ export class BackupConfiguration {
     const { error, data } = await DeviceModule.getOrCreateDevice();
     if (error) return [];
 
-    const enabledBackupEntries = await DeviceModule.getBackupsFromDevice(data, true);
+    const { error: backupsError, data: enabledBackupEntries } = await DeviceModule.getBackupsFromDevice(data, true);
+    if (backupsError || !enabledBackupEntries) return [];
 
     return this.map(enabledBackupEntries, data.bucket);
   }

src/apps/main/interface.d.ts

@@ -36,7 +36,7 @@ export interface IElectronAPI {
 
   getOrCreateDevice: () => Promise<Result<Device, Error>>;
 
-  getBackupsFromDevice: (device: Device, isCurrent?: boolean) => Promise<Array<BackupInfo>>;
+  getBackupsFromDevice: (device: Device, isCurrent?: boolean) => Promise<Result<Array<BackupInfo>, Error>>;
 
   addBackup: () => Promise<Result<BackupInfo, Error>>;
 
@@ -62,7 +62,7 @@ export interface IElectronAPI {
 
   abortDownloadBackups: (deviceId: string) => void;
 
-  renameDevice: (deviceName: string) => Promise<Device>;
+  renameDevice: (deviceName: string) => Promise<Result<Device, Error>>;
   devices: {
     getDevices: () => Promise<Array<Device>>;
   };

src/apps/main/preload.d.ts

@@ -100,17 +100,26 @@ declare interface Window {
 
     path: typeof import('path');
 
-    getOrCreateDevice: typeof import('../../backend/features/device/device.module').DeviceModule.getOrCreateDevice;
+    getOrCreateDevice: () => Promise<
+      import('../../context/shared/domain/Result').Result<import('../main/device/service').Device, Error>
+    >;
 
-    renameDevice: typeof import('../../backend/features/device/device.module').DeviceModule.renameDevice;
+    renameDevice: (
+      deviceName: string,
+    ) => Promise<import('../../context/shared/domain/Result').Result<import('../main/device/service').Device, Error>>;
 
     devices: {
       getDevices: () => Promise<Array<Device>>;
     };
 
     onDeviceCreated(func: (value: Device) => void): () => void;
 
-    getBackupsFromDevice: typeof import('../../backend/features/device/device.module').DeviceModule.getBackupsFromDevice;
+    getBackupsFromDevice: (
+      device: import('../main/device/service').Device,
+      isCurrent?: boolean,
+    ) => Promise<
+      import('../../context/shared/domain/Result').Result<import('../backups/BackupInfo').BackupInfo[], Error>
+    >;
 
     addBackup: typeof import('../../backend/features/backup/add-backup').addBackup;
 

src/apps/renderer/context/DeviceContext.tsx

@@ -58,18 +58,15 @@ export function DeviceProvider({ children }: { children: ReactNode }) {
   const deviceRename = async (deviceName: string) => {
     setDeviceState({ status: 'LOADING' });
 
-    try {
-      const updatedDevice = await window.electron.renameDevice(deviceName);
-      setDeviceState({ status: 'SUCCESS', device: updatedDevice });
-      setCurrent(updatedDevice);
-      setSelected(updatedDevice);
-    } catch (err) {
-      window.electron.logger.error({
-        msg: '[RENDERER] Failed to rename device',
-        error: err,
-      });
+    const { error, data: updatedDevice } = await window.electron.renameDevice(deviceName);
+    if (error || !updatedDevice) {
       setDeviceState({ status: 'ERROR' });
+      return;
     }
+
+    setDeviceState({ status: 'SUCCESS', device: updatedDevice });
+    setCurrent(updatedDevice);
+    setSelected(updatedDevice);
   };
 
   return (

src/apps/renderer/hooks/backups/useBackups.tsx

@@ -23,10 +23,17 @@ export function useBackups(): BackupContextProps {
   const [backups, setBackups] = useState<Array<BackupInfo>>([]);
   const [hasExistingBackups, setHasExistingBackups] = useState(false);
 
-  async function fetchBackups(): Promise<void> {
-    if (!selected) return;
-    const backups = await window.electron.getBackupsFromDevice(selected, selected === current);
-    setBackups(backups);
+  async function fetchBackups(): Promise<boolean> {
+    if (!selected) return true;
+
+    const { error, data } = await window.electron.getBackupsFromDevice(selected, selected === current);
+    if (error || !data) {
+      setBackups([]);
+      return false;
+    }
+
+    setBackups(data);
+    return true;
   }
 
   const validateIfBackupExists = async () => {
@@ -38,13 +45,14 @@ export function useBackups(): BackupContextProps {
     setBackupsState('LOADING');
     setBackups([]);
 
-    try {
-      await fetchBackups();
-      setBackupsState('SUCCESS');
-    } catch {
+    const isLoaded = await fetchBackups();
+    if (!isLoaded) {
       setBackupsState('ERROR');
       setBackups([]);
+      return;
     }
+
+    setBackupsState('SUCCESS');
   }
 
   useEffect(() => {

src/backend/features/device/createAndSetupNewDevice.test.ts

@@ -0,0 +1,103 @@
+import { BrowserWindow } from 'electron';
+import { broadcastToWindows } from '../../../apps/main/windows';
+import { DependencyInjectionUserProvider } from '../../../apps/shared/dependency-injection/DependencyInjectionUserProvider';
+import { createNewDevice } from './createNewDevice';
+import { createAndSetupNewDevice } from './createAndSetupNewDevice';
+import { getDeviceIdentifier } from './getDeviceIdentifier';
+
+vi.mock('electron', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('electron')>();
+
+  return {
+    ...actual,
+    app: {
+      ...actual.app,
+      getPath: vi.fn().mockReturnValue('/tmp/backups'),
+    },
+    ipcMain: {
+      ...actual.ipcMain,
+      on: vi.fn(),
+      handle: vi.fn(),
+      removeHandler: vi.fn(),
+    },
+    BrowserWindow: {
+      ...actual.BrowserWindow,
+      getAllWindows: vi.fn(),
+    },
+  };
+});
+vi.mock('./getDeviceIdentifier');
+vi.mock('./createNewDevice');
+vi.mock('../../../apps/main/windows', () => ({
+  broadcastToWindows: vi.fn(),
+}));
+vi.mock('../../../apps/shared/dependency-injection/DependencyInjectionUserProvider', () => ({
+  DependencyInjectionUserProvider: { get: vi.fn(), updateUser: vi.fn() },
+}));
+
+describe('createAndSetupNewDevice', () => {
+  const mockedGetDeviceIdentifier = vi.mocked(getDeviceIdentifier);
+  const mockedCreateNewDevice = vi.mocked(createNewDevice);
+  const mockedBroadcastToWindows = vi.mocked(broadcastToWindows);
+  const mockedBrowserWindowGetAllWindows = vi.mocked(BrowserWindow.getAllWindows);
+  const mockedUserProviderGet = vi.mocked(DependencyInjectionUserProvider.get);
+  const mockedUserProviderUpdate = vi.mocked(DependencyInjectionUserProvider.updateUser);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockedUserProviderGet.mockReturnValue({ backupsBucket: '' } as never);
+    mockedBrowserWindowGetAllWindows.mockReturnValue([] as never);
+  });
+
+  it('should return only error when the device identifier is unavailable', async () => {
+    const error = new Error('Missing device identifier');
+    mockedGetDeviceIdentifier.mockReturnValue({ error });
+
+    const result = await createAndSetupNewDevice();
+
+    expect(result).toStrictEqual({ error });
+    expect(mockedCreateNewDevice).not.toHaveBeenCalled();
+    expect(mockedBroadcastToWindows).not.toHaveBeenCalled();
+  });
+
+  it('should return only error when the device creation fails', async () => {
+    const error = new Error('Create device failed');
+    mockedGetDeviceIdentifier.mockReturnValue({
+      data: { key: 'key', platform: 'linux', hostname: 'host' },
+    });
+    mockedCreateNewDevice.mockResolvedValue({ error });
+
+    const result = await createAndSetupNewDevice();
+
+    expect(result).toStrictEqual({ error });
+    expect(mockedBroadcastToWindows).not.toHaveBeenCalled();
+    expect(mockedUserProviderUpdate).not.toHaveBeenCalled();
+  });
+
+  it('should update the user and notify windows when the device is created', async () => {
+    const user = { backupsBucket: '' };
+    const send = vi.fn();
+    const device = {
+      id: 1,
+      uuid: 'device-uuid',
+      name: 'Laptop',
+      bucket: 'bucket-1',
+      removed: false,
+      hasBackups: true,
+    };
+    mockedUserProviderGet.mockReturnValue(user as never);
+    mockedBrowserWindowGetAllWindows.mockReturnValue([{ webContents: { send } }] as never);
+    mockedGetDeviceIdentifier.mockReturnValue({
+      data: { key: 'key', platform: 'linux', hostname: 'host' },
+    });
+    mockedCreateNewDevice.mockResolvedValue({ data: device });
+
+    const result = await createAndSetupNewDevice();
+
+    expect(result).toStrictEqual({ data: device });
+    expect(user.backupsBucket).toBe('bucket-1');
+    expect(mockedUserProviderUpdate).toHaveBeenCalledWith(user);
+    expect(send).toHaveBeenCalledWith('reinitialize-backups');
+    expect(mockedBroadcastToWindows).toHaveBeenCalledWith('device-created', device);
+  });
+});

src/backend/features/device/createAndSetupNewDevice.ts

@@ -9,17 +9,16 @@ export async function createAndSetupNewDevice() {
   const { error, data: deviceIdentifier } = getDeviceIdentifier();
   if (error) return { error };
 
-  const createNewDeviceEither = await createNewDevice(deviceIdentifier);
-  if (createNewDeviceEither.isLeft()) {
+  const { error: createDeviceError, data: device } = await createNewDevice(deviceIdentifier);
+  if (createDeviceError) {
     logger.error({
       tag: 'BACKUPS',
       msg: '[DEVICE] Error creating new device',
-      error: createNewDeviceEither.getLeft(),
+      error: createDeviceError,
     });
-    return { error: createNewDeviceEither.getLeft() };
+    return { error: createDeviceError };
   }
 
-  const device = createNewDeviceEither.getRight();
   const user = DependencyInjectionUserProvider.get();
   user.backupsBucket = device.bucket;
   DependencyInjectionUserProvider.updateUser(user);

src/backend/features/device/createNewDevice.test.ts

@@ -0,0 +1,42 @@
+import { createNewDevice } from './createNewDevice';
+import { createUniqueDevice } from './createUniqueDevice';
+import { saveDeviceToConfig } from './saveDeviceToConfig';
+
+vi.mock('./createUniqueDevice');
+vi.mock('./saveDeviceToConfig');
+
+describe('createNewDevice', () => {
+  const mockedCreateUniqueDevice = vi.mocked(createUniqueDevice);
+  const mockedSaveDeviceToConfig = vi.mocked(saveDeviceToConfig);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return only error when creating a unique device fails', async () => {
+    const error = new Error('Could not create device');
+    mockedCreateUniqueDevice.mockResolvedValue({ error });
+
+    const result = await createNewDevice({ key: 'key', platform: 'linux', hostname: 'host' });
+
+    expect(result).toStrictEqual({ error });
+    expect(mockedSaveDeviceToConfig).not.toHaveBeenCalled();
+  });
+
+  it('should save the device to config when creating the device succeeds', async () => {
+    const device = {
+      id: 1,
+      uuid: 'device-uuid',
+      name: 'Laptop',
+      bucket: 'bucket-1',
+      removed: false,
+      hasBackups: true,
+    };
+    mockedCreateUniqueDevice.mockResolvedValue({ data: device });
+
+    const result = await createNewDevice({ key: 'key', platform: 'linux', hostname: 'host' });
+
+    expect(result).toStrictEqual({ data: device });
+    expect(mockedSaveDeviceToConfig).toHaveBeenCalledWith(device);
+  });
+});

src/backend/features/device/createNewDevice.ts

@@ -1,15 +1,13 @@
-import { Either, right } from './../../../context/shared/domain/Either';
-import { Device } from '../backup/types/Device';
+import { Device } from '../../../apps/main/device/service';
+import { Result } from '../../../context/shared/domain/Result';
 import { createUniqueDevice } from './createUniqueDevice';
 import { saveDeviceToConfig } from './saveDeviceToConfig';
 import { DeviceIdentifierDTO } from './device.types';
 
-export async function createNewDevice(deviceIdentifier: DeviceIdentifierDTO): Promise<Either<Error, Device>> {
-  const createUniqueDeviceEither = await createUniqueDevice(deviceIdentifier);
-  if (createUniqueDeviceEither.isRight()) {
-    const device = createUniqueDeviceEither.getRight();
-    saveDeviceToConfig(device);
-    return right(device);
-  }
-  return createUniqueDeviceEither;
+export async function createNewDevice(deviceIdentifier: DeviceIdentifierDTO): Promise<Result<Device, Error>> {
+  const { data: device, error } = await createUniqueDevice(deviceIdentifier);
+  if (error) return { error };
+
+  saveDeviceToConfig(device);
+  return { data: device };
 }

src/backend/features/device/createUniqueDevice.ts

@@ -2,18 +2,19 @@ import { Device } from '../backup/types/Device';
 import { hostname } from 'node:os';
 import { logger } from '@internxt/drive-desktop-core/build/backend';
 import { tryCreateDevice } from './tryCreateDevice';
-import { Either, left, right } from '../../../context/shared/domain/Either';
 import { addUnknownDeviceIssue } from './addUnknownDeviceIssue';
 import { DeviceIdentifierDTO } from './device.types';
+import { Result } from '../../../context/shared/domain/Result';
+import { BackupError } from '../../../infra/drive-server/services/backup/backup.error';
 /**
  * Creates a new device with a unique name
- * @returns Either containing the created device or an error if device creation fails after multiple attempts
+ * @returns Result containing the created device or an error if device creation fails after multiple attempts
  * @param attempts The number of attempts to create a device with a unique name, defaults to 1000
  */
 export async function createUniqueDevice(
   deviceIdentifier: DeviceIdentifierDTO,
   attempts = 1000,
-): Promise<Either<Error, Device>> {
+): Promise<Result<Device, Error>> {
   const baseName = hostname();
   const nameVariants = [baseName, ...Array.from({ length: attempts }, (_, i) => `${baseName} (${i + 1})`)];
 
@@ -22,21 +23,22 @@ export async function createUniqueDevice(
       tag: 'BACKUPS',
       msg: `Trying to create device with name "${name}"`,
     });
-    const tryCreateDeviceEither = await tryCreateDevice(name, deviceIdentifier);
+    const { data, error } = await tryCreateDevice(name, deviceIdentifier);
 
-    if (tryCreateDeviceEither.isRight()) {
-      return right(tryCreateDeviceEither.getRight());
+    if (data) {
+      return { data };
     }
-    const error = tryCreateDeviceEither.getLeft();
-    if (error.message == 'Error creating device') {
-      return left(tryCreateDeviceEither.getLeft());
+
+    if (!(error instanceof BackupError && error.code === 'ALREADY_EXISTS')) {
+      return { error };
     }
   }
+
   const finalError = logger.error({
     tag: 'BACKUPS',
     msg: 'Could not create device trying different names',
   });
 
   addUnknownDeviceIssue(finalError);
-  return left(finalError);
+  return { error: finalError };
 }