Refactor codes using a new IResult which supports Parameter Type.

src/actions/catalog.action.ts

@@ -10,8 +10,6 @@ import { KeyboardLabelLang } from '../services/labellang/KeyLabelLangs';
 import {
   AbstractKeymapData,
   IFirmwareBuildingTask,
-  isError,
-  isSuccessful,
 } from '../services/storage/Storage';
 import { KeycodeList } from '../services/hid/KeycodeList';
 import {
@@ -23,6 +21,7 @@ import { ThunkAction, ThunkDispatch } from 'redux-thunk';
 import { getEncoderIdList } from './utils';
 import { KC_NO } from '../services/hid/KeycodeInfoList';
 import { StorageActions } from './storage.action';
+import { isError, isSuccessful } from '../types';
 
 export const CATALOG_APP_ACTIONS = `@CatalogApp`;
 export const CATALOG_APP_UPDATE_PHASE = `${CATALOG_APP_ACTIONS}/UpdatePhase`;

src/actions/firmware.action.ts

@@ -11,12 +11,9 @@ import {
 } from '../store/state';
 import { sendEventToGoogleAnalytics } from '../utils/GoogleAnalytics';
 import intelHex from 'intel-hex';
-import {
-  IFirmware,
-  IFirmwareBuildingTask,
-  isError,
-} from '../services/storage/Storage';
+import { IFirmware, IFirmwareBuildingTask } from '../services/storage/Storage';
 import { IBootloaderType } from '../services/firmware/Types';
+import { isError } from '../types';
 
 export const UPLOAD_FIRMWARE_DIALOG_ACTIONS = '@UploadFirmwareDialog';
 export const UPLOAD_FIRMWARE_DIALOG_UPDATE_OPEN = `${UPLOAD_FIRMWARE_DIALOG_ACTIONS}/UploadOpen`;
@@ -317,7 +314,7 @@ export const firmwareActionsThunk = {
 
       const writeResult = await firmwareWriter.write(
         bootloaderType,
-        flashBytes,
+        new Uint8Array(flashBytes),
         null,
         (message, lineBreak) => {
           dispatch(FlashFirmwareDialogActions.appendLog(message, lineBreak));
@@ -360,7 +357,7 @@ export const firmwareActionsThunk = {
           handleError(error, cause);
         }
       );
-      if (!writeResult.success) {
+      if (isError(writeResult)) {
         handleError(writeResult.error!, writeResult.cause);
         return;
       }

src/actions/organizations.actions.ts

@@ -2,7 +2,8 @@ import { IOrganizationsPhase, RootState } from '../store/state';
 import { ThunkAction, ThunkDispatch } from 'redux-thunk';
 import { NotificationActions } from './actions';
 import { StorageActions } from './storage.action';
-import { IOrganizationMember, isError } from '../services/storage/Storage';
+import { IOrganizationMember } from '../services/storage/Storage';
+import { isError } from '../types';
 
 export const ORGANIZATIONS_APP_ACTIONS = '@Organizations!App';
 export const ORGANIZATIONS_APP_UPDATE_PHASE = `${ORGANIZATIONS_APP_ACTIONS}/UpdatePhase`;

src/actions/storage.action.ts

@@ -28,8 +28,6 @@ import {
   IFirmwareBuildingTask,
   IKeyboardDefinitionDocument,
   IOrganization,
-  isError,
-  isSuccessful,
   KeyboardDefinitionStatus,
   SavedKeymapData,
 } from '../services/storage/Storage';
@@ -43,6 +41,7 @@ import { sendEventToGoogleAnalytics } from '../utils/GoogleAnalytics';
 import { CatalogAppActions } from './catalog.action';
 import * as qs from 'qs';
 import { IBootloaderType } from '../services/firmware/Types';
+import { isError, isSuccessful } from '../types';
 
 export const STORAGE_ACTIONS = '@Storage';
 export const STORAGE_UPDATE_KEYBOARD_DEFINITION = `${STORAGE_ACTIONS}/UpdateKeyboardDefinition`;

src/services/firmware/Bootloader.ts

@@ -1,12 +1,8 @@
+import { IEmptyResult, IResult } from '../../types';
 import {
   FirmwareWriterPhaseListener,
   FirmwareWriterProgressListener,
 } from './FirmwareWriter';
-import { IResult } from './Types';
-
-export interface IBootloaderReadResult extends IResult {
-  bytes?: Uint8Array;
-}
 
 export interface IBootloader {
   read(
@@ -16,7 +12,7 @@ export interface IBootloader {
     progress: FirmwareWriterProgressListener,
     // eslint-disable-next-line no-unused-vars
     phase: FirmwareWriterPhaseListener
-  ): Promise<IBootloaderReadResult>;
+  ): Promise<IResult<{ bytes: Uint8Array }>>;
 
   write(
     // eslint-disable-next-line no-unused-vars
@@ -27,7 +23,7 @@ export interface IBootloader {
     progress: FirmwareWriterProgressListener,
     // eslint-disable-next-line no-unused-vars
     phase: FirmwareWriterPhaseListener
-  ): Promise<IResult>;
+  ): Promise<IEmptyResult>;
 
   verify(
     // eslint-disable-next-line no-unused-vars
@@ -36,5 +32,5 @@ export interface IBootloader {
     progress: FirmwareWriterProgressListener,
     // eslint-disable-next-line no-unused-vars
     phase: FirmwareWriterPhaseListener
-  ): Promise<IResult>;
+  ): Promise<IEmptyResult>;
 }

src/services/firmware/Command.ts

@@ -1,20 +1,19 @@
+import {
+  errorResultOf,
+  IEmptyResult,
+  IResult,
+  isError,
+  successResultOf,
+} from '../../types';
 import { ISerial } from './serial/Serial';
-import { IResult } from './Types';
 
 export interface ICommandRequest {}
 
 export interface ICommandResponse {}
 
-export interface ICommandResult<T> {
-  success: boolean;
-  response?: T;
-  error?: string;
-  cause?: any;
-}
-
 export interface ICommandResponseHandler<T extends ICommandResponse> {
   // eslint-disable-next-line
-  (result: ICommandResult<T>): Promise<void>;
+  (result: IResult<{ response: T }>): Promise<void>;
 }
 
 export abstract class AbstractCommand<
@@ -44,19 +43,18 @@ export abstract class AbstractCommand<
   }
 
   // eslint-disable-next-line no-unused-vars
-  protected async verify(_serial: ISerial): Promise<IResult> {
-    return {
-      success: false,
-      error: 'Verification logic not implemented.',
-    };
+  protected async verify(_serial: ISerial): Promise<IEmptyResult> {
+    return errorResultOf('Verification logic not implemented.');
   }
 
   abstract createRequest(): string | Uint8Array | null;
   abstract getReadBytesLength(): number;
   // eslint-disable-next-line no-unused-vars
   abstract createResponse(resultArray: Uint8Array): TResponse;
 
-  async writeRequest(serial: ISerial): Promise<ICommandResult<TResponse>> {
+  async writeRequest(
+    serial: ISerial
+  ): Promise<IResult<{ response: TResponse }>> {
     const request = this.createRequest();
     if (request !== null) {
       let writeResult;
@@ -65,12 +63,8 @@ export abstract class AbstractCommand<
       } else {
         writeResult = await serial.writeBytes(request as Uint8Array);
       }
-      if (!writeResult.success) {
-        return {
-          success: false,
-          error: writeResult.error,
-          cause: writeResult.cause,
-        };
+      if (isError(writeResult)) {
+        return writeResult;
       }
     }
     const readBytesLength = this.getReadBytesLength();
@@ -79,33 +73,30 @@ export abstract class AbstractCommand<
         this.getReadBytesLength(),
         this.getTimeout()
       );
-      if (!readResult.success) {
-        return {
-          success: false,
-          error: readResult.error,
-          cause: readResult.cause,
-        };
+      if (isError(readResult)) {
+        return readResult;
       }
       if (this.isVerify()) {
         const verifyResult = await this.verify(serial);
-        if (!verifyResult.success) {
+        if (isError(verifyResult)) {
           return verifyResult;
         }
       }
-      return {
-        success: true,
-        response: this.createResponse(readResult.bytes!),
-      };
+      return successResultOf({
+        response: this.createResponse(readResult.value.bytes),
+      });
     } else {
       if (this.isVerify()) {
         const verifyResult = await this.verify(serial);
-        if (!verifyResult.success) {
+        if (isError(verifyResult)) {
           return verifyResult;
         }
       }
-      return {
-        success: true,
-      };
+      // No response expected, return an empty result.
+      console.warn('No response expected, returning an empty result.');
+      return successResultOf({
+        response: this.createResponse(new Uint8Array(0)),
+      });
     }
   }
 }

src/services/firmware/FirmwareWriter.ts

@@ -1,14 +1,11 @@
-import { IBootloaderType, IErrorHandler, IResult } from './Types';
+import { IEmptyResult } from '../../types';
+import { IBootloaderType, IErrorHandler } from './Types';
 
 export type FirmwareWriterProgressListener = (
   message: string,
   lineBreak?: boolean
 ) => void;
 
-export interface IFirmwareWriterReadResult extends IResult {
-  bytes?: Uint8Array;
-}
-
 export type IFirmwareWriterPhase =
   | 'opened'
   | 'initialized'
@@ -28,5 +25,5 @@ export interface IFirmwareWriter {
     progress: FirmwareWriterProgressListener,
     phase: FirmwareWriterPhaseListener,
     errorHandler: IErrorHandler
-  ): Promise<IResult>;
+  ): Promise<IEmptyResult>;
 }

src/services/firmware/FirmwareWriterWebApiImpl.ts

@@ -5,13 +5,14 @@ import {
 } from './FirmwareWriter';
 import { CaterinaBootloader } from './caterina/CaterinaBootloader';
 import { WebSerial } from './serial/WebSerial';
-import { IBootloaderType, IErrorHandler, IResult } from './Types';
+import { IBootloaderType, IErrorHandler } from './Types';
 import { ISerial } from './serial/Serial';
 import { IUsb } from './usb/Usb';
 import WebUsb from './usb/WebUsb';
 import { IBootloader } from './Bootloader';
 import { DfuBootloader } from './dfu/DfuBootloader';
 import { WebFileSystem } from './copy/WebFileSystem';
+import { IEmptyResult, isError } from '../../types';
 
 const BAUD_RATE = 115200;
 const BUFFER_SIZE = 81920;
@@ -25,15 +26,15 @@ export class FirmwareWriterWebApiImpl implements IFirmwareWriter {
     progress: FirmwareWriterProgressListener,
     phase: FirmwareWriterPhaseListener,
     errorHandler: IErrorHandler
-  ): Promise<IResult> {
+  ): Promise<IEmptyResult> {
     if (bootloaderType === 'caterina') {
       const serial: ISerial = new WebSerial(CHUNK_SIZE);
       const openResult = await serial.open(
         BAUD_RATE,
         BUFFER_SIZE,
         errorHandler
       );
-      if (!openResult.success) {
+      if (isError(openResult)) {
         return openResult;
       }
       phase('opened');
@@ -42,24 +43,25 @@ export class FirmwareWriterWebApiImpl implements IFirmwareWriter {
     } else if (bootloaderType === 'dfu') {
       const usb: IUsb = new WebUsb();
       const openResult = await usb.open();
-      if (!openResult.success) {
+      if (isError(openResult)) {
         return openResult;
       }
       phase('opened');
       const createDfuBootloaderResult = DfuBootloader.createDfuBootloader(
         usb,
         progress
       );
-      if (!createDfuBootloaderResult.success) {
+      if (isError(createDfuBootloaderResult)) {
         await usb.close();
         return createDfuBootloaderResult;
       }
-      const bootloader: IBootloader = createDfuBootloaderResult.bootloader!;
+      const bootloader: IBootloader =
+        createDfuBootloaderResult.value.bootloader;
       return await bootloader.write(flashBytes, eepromBytes, progress, phase);
     } else if (bootloaderType === 'copy') {
       const fileSystem = new WebFileSystem();
       const openResult = await fileSystem.open();
-      if (!openResult.success) {
+      if (isError(openResult)) {
         return openResult;
       }
       phase('opened');

src/services/firmware/Types.ts

@@ -1,9 +1,3 @@
-export type IResult = {
-  success: boolean;
-  error?: string;
-  cause?: any;
-};
-
 export const ALL_FIRMWARE_FLASH_TYPE = ['flash', 'eeprom'] as const;
 type firmwareFlashTypeTuple = typeof ALL_FIRMWARE_FLASH_TYPE;
 export type FirmwareFlashType = firmwareFlashTypeTuple[number];