✨ (core) [DSDK-335]: Limit the usage of as keyword for type asserti…

…on (#96)

apps/sample/src/components/ApduView/index.tsx

@@ -78,7 +78,7 @@ export const ApduView: React.FC = () => {
       try {
         rawApduResponse = await sdk.sendApdu({
           // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-          sessionId: selectedSessionId!,
+          sessionId: selectedSessionId ?? "",
           apdu: getRawApdu(values),
         });
         setApduResponse(rawApduResponse);

apps/sample/src/components/Sidebar/index.tsx

@@ -53,7 +53,7 @@ export const Sidebar: React.FC = () => {
       .getVersion()
       .then((v) => setVersion(v))
       .catch((error: unknown) => {
-        console.error(error as Error);
+        console.error(new Error(String(error)));
         setVersion("");
       });
   }, [sdk]);

apps/sample/src/hooks/useApduForm.ts

@@ -37,7 +37,7 @@ export function useApduForm() {
               .map((char) => Number(`0x${char}`))
               .filter((nbr) => !Number.isNaN(nbr)),
           ],
-          [] as number[],
+          Array<number>(),
         ),
       ),
     [],

packages/config/eslint/index.js

@@ -5,7 +5,7 @@ const project = resolve(process.cwd(), "tsconfig.json");
 /** @type {import("eslint").Linter.Config} */
 module.exports = {
   extends: ["eslint:recommended", "prettier", "turbo"],
-  plugins: ["simple-import-sort"],
+  plugins: ["no-type-assertion", "simple-import-sort"],
   globals: {
     React: true,
     JSX: true,
@@ -82,6 +82,13 @@ module.exports = {
           "error",
           { argsIgnorePattern: "^_" },
         ],
+        "no-type-assertion/no-type-assertion": "error",
+      },
+    },
+    {
+      files: ["**/*.test.ts", "**/*.stub.ts"],
+      rules: {
+        "no-type-assertion/no-type-assertion": "off",
       },
     },
   ],

packages/config/eslint/package.json

@@ -12,6 +12,7 @@
     "@vercel/style-guide": "^6.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-turbo": "^1.13.2",
+    "eslint-plugin-no-type-assertion": "^1.3.0",
     "eslint-plugin-simple-import-sort": "^12.0.0"
   }
 }

packages/core/src/api/Error.ts

@@ -1,5 +1,5 @@
 export interface SdkError {
   readonly _tag: string;
-  originalError?: Error;
+  originalError?: unknown;
   // [could] message?: string;
 }

packages/core/src/api/apdu/utils/ApduParser.ts

@@ -111,16 +111,14 @@ export class ApduParser {
   extractFieldTLVEncoded(): TaggedField | undefined {
     if (this._outOfRange(2)) return;
 
-    // extract the tag field
     const tag = this.extract8BitUint();
     const value = this.extractFieldLVEncoded();
 
-    // if the field is inconsistent then roll back to the initial point
-    if (!value) {
+    if (!tag || !value) {
       this._index--;
       return;
     }
-    return { tag, value } as TaggedField;
+    return { tag, value };
   }
 
   /**

packages/core/src/api/command/os/GetAppAndVersionCommand.ts

@@ -58,10 +58,10 @@ export class GetAppAndVersionCommand
     const version = parser.encodeToString(parser.extractFieldLVEncoded());
 
     if (parser.getUnparsedRemainingLength() === 0) {
-      return { name, version } as GetAppAndVersionResponse;
+      return { name, version };
     }
 
     const flags = parser.extractFieldLVEncoded();
-    return { name, version, flags } as GetAppAndVersionResponse;
+    return { name, version, flags };
   }
 }

packages/core/src/internal/config/data/LocalConfigDataSource.ts

@@ -1,7 +1,7 @@
 import { injectable } from "inversify";
 import { Either } from "purify-ts";
 
-import { Config } from "@internal/config/model/Config";
+import { Config, isConfig } from "@internal/config/model/Config";
 import {
   JSONParseError,
   LocalConfigFailure,
@@ -18,21 +18,26 @@ const version = {
 
 export const stubFsReadFile = () => JSON.stringify(version);
 
+@injectable()
 /**
- *
- * class FileLocalConfigDataSource
- * This is a local data source that reads the config from a local file.
- *
+ * The data source for retrieving local configuration.
  */
-@injectable()
 export class FileLocalConfigDataSource implements LocalConfigDataSource {
+  /**
+   * Retrieves the local configuration.
+   * @returns An `Either` containing either a `LocalConfigFailure` or a `Config` object.
+   */
   getConfig(): Either<LocalConfigFailure, Config> {
     return Either.encase(() => stubFsReadFile())
       .mapLeft((error) => new ReadFileError(error))
       .chain((str) => {
-        return Either.encase(() => JSON.parse(str) as Config).mapLeft(
-          (error) => new JSONParseError(error),
-        );
+        return Either.encase(() => {
+          const config: unknown = JSON.parse(str);
+          if (isConfig(config)) {
+            return config;
+          }
+          throw new Error("Invalid config file");
+        }).mapLeft((error) => new JSONParseError(error));
       });
   }
 }

packages/core/src/internal/config/model/Config.ts

@@ -4,3 +4,19 @@ export type Config = {
   version: string;
   name: string;
 };
+
+/**
+ * Checks if the provided object is a valid Config object.
+ * @param obj - The object to be checked.
+ * @returns A boolean indicating whether the object is a Config object.
+ */
+export function isConfig(obj: unknown): obj is Config {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    "version" in obj &&
+    "name" in obj &&
+    typeof obj.version === "string" &&
+    typeof obj.name === "string"
+  );
+}

packages/core/src/internal/device-model/data/StaticDeviceModelDataSource.ts

@@ -83,6 +83,7 @@ export class StaticDeviceModelDataSource implements DeviceModelDataSource {
   ): InternalDeviceModel[] {
     return this.getAllDeviceModels().filter((deviceModel) => {
       return Object.entries(params).every(([key, value]) => {
+        // eslint-disable-next-line no-type-assertion/no-type-assertion
         return deviceModel[key as keyof InternalDeviceModel] === value;
       });
     });

packages/core/src/internal/device-session/model/DeviceSessionRefresher.ts

@@ -97,11 +97,15 @@ export class DeviceSessionRefresher {
         filter((parsedResponse) => parsedResponse !== null),
       )
       .subscribe((parsedResponse: GetAppAndVersionResponse | null) => {
-        // batteryStatus and firmwareVersion are not available in the polling response.
+        // This should never happen and it should be abled to handle in next version of TypeScript.
+        if (parsedResponse === null) {
+          return;
+        }
+        // `batteryStatus` and `firmwareVersion` are not available in the polling response.
         updateStateFn({
           sessionStateType: DeviceSessionStateType.ReadyWithoutSecureChannel,
           deviceStatus: this._deviceStatus,
-          currentApp: parsedResponse!.name,
+          currentApp: parsedResponse.name,
         });
       });
   }

packages/core/src/internal/device-session/service/DefaultApduReceiverService.ts

@@ -57,8 +57,10 @@ export class DefaultApduReceiverService implements ApduReceiverService {
         data: { frame: value.getRawData() },
       });
       this._pendingFrames.push(value);
-
-      const dataSize = this._pendingFrames[0]!.getHeader().getDataLength();
+      if (!this._pendingFrames[0]) {
+        return Nothing;
+      }
+      const dataSize = this._pendingFrames[0].getHeader().getDataLength();
       return this.getCompleteFrame(dataSize);
     });
   }

packages/core/src/internal/usb/model/Errors.ts

@@ -6,59 +6,63 @@ export type PromptDeviceAccessError =
 
 export type ConnectError = UnknownDeviceError | OpeningConnectionError;
 
-export class DeviceNotRecognizedError implements SdkError {
-  readonly _tag = "DeviceNotRecognizedError";
-  originalError?: Error;
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+class GeneralSdkError implements SdkError {
+  _tag = "GeneralSdkError";
+  originalError?: unknown;
+  constructor(err?: unknown) {
+    if (err instanceof Error) {
+      this.originalError = err;
+    } else {
+      this.originalError = new Error(String(err));
+    }
   }
 }
 
-export class NoAccessibleDeviceError implements SdkError {
-  readonly _tag = "NoAccessibleDeviceError";
-  originalError?: Error;
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+export class DeviceNotRecognizedError extends GeneralSdkError {
+  override readonly _tag = "DeviceNotRecognizedError";
+  constructor(readonly err?: unknown) {
+    super(err);
   }
 }
 
-export class OpeningConnectionError implements SdkError {
-  readonly _tag = "ConnectionOpeningError";
-  originalError?: Error;
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+export class NoAccessibleDeviceError extends GeneralSdkError {
+  override readonly _tag = "NoAccessibleDeviceError";
+  constructor(readonly err?: unknown) {
+    super(err);
   }
 }
 
-export class UnknownDeviceError implements SdkError {
-  readonly _tag = "UnknownDeviceError";
-  originalError?: Error;
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+export class OpeningConnectionError extends GeneralSdkError {
+  override readonly _tag = "ConnectionOpeningError";
+  constructor(readonly err?: unknown) {
+    super(err);
   }
 }
 
-export class UsbHidTransportNotSupportedError implements SdkError {
-  readonly _tag = "UsbHidTransportNotSupportedError";
-  originalError?: Error;
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+export class UnknownDeviceError extends GeneralSdkError {
+  override readonly _tag = "UnknownDeviceError";
+  constructor(readonly err?: unknown) {
+    super(err);
   }
 }
 
-export class SendApduConcurrencyError implements SdkError {
-  readonly _tag = "SendApduConcurrencyError";
-  originalError?: Error;
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+export class UsbHidTransportNotSupportedError extends GeneralSdkError {
+  override readonly _tag = "UsbHidTransportNotSupportedError";
+  constructor(readonly err?: unknown) {
+    super(err);
   }
 }
 
-export class DisconnectError implements SdkError {
-  readonly _tag = "DisconnectError";
-  originalError?: Error;
+export class SendApduConcurrencyError extends GeneralSdkError {
+  override readonly _tag = "SendApduConcurrencyError";
+  constructor(readonly err?: unknown) {
+    super(err);
+  }
+}
 
-  constructor(readonly err?: Error) {
-    this.originalError = err;
+export class DisconnectError extends GeneralSdkError {
+  override readonly _tag = "DisconnectError";
+  constructor(readonly err?: unknown) {
+    super(err);
   }
 }

packages/core/src/internal/usb/model/HIDDevice.stub.ts

@@ -1,4 +1,4 @@
-const oninputreport = jest.fn();
+const oninputreport = jest.fn().mockResolvedValue(void 0);
 export const hidDeviceStubBuilder = (
   props: Partial<HIDDevice> = {},
 ): HIDDevice => ({
@@ -10,7 +10,7 @@ export const hidDeviceStubBuilder = (
   open: jest.fn(),
   oninputreport,
   close: jest.fn(),
-  sendReport: jest.fn(async () => oninputreport()),
+  sendReport: jest.fn().mockImplementation(() => oninputreport()),
   sendFeatureReport: jest.fn(),
   forget: jest.fn(),
   receiveFeatureReport: jest.fn(),

packages/core/src/internal/usb/transport/UsbHidDeviceConnection.test.ts

@@ -38,7 +38,7 @@ describe("UsbHidDeviceConnection", () => {
     expect(cDevice).toStrictEqual(device);
   });
 
-  it("should send APDU through hid report", async () => {
+  it("should send APDU through hid report", () => {
     // given
     const connection = new UsbHidDeviceConnection(
       { device, apduSender, apduReceiver },
@@ -50,7 +50,7 @@ describe("UsbHidDeviceConnection", () => {
     expect(device.sendReport).toHaveBeenCalled();
   });
 
-  it("should receive APDU through hid report", async () => {
+  it("should receive APDU through hid report", () => {
     // given
     device.sendReport = jest.fn(() =>
       Promise.resolve(

packages/core/src/internal/usb/transport/WebUsbHidTransport.test.ts

@@ -244,7 +244,7 @@ describe("WebUsbHidTransport", () => {
         const connect = await transport.connect(connectParams);
 
         expect(connect).toStrictEqual(
-          Left(new UnknownDeviceError(new Error("Unknown device fake"))),
+          Left(new UnknownDeviceError("Unknown device fake")),
         );
       });
 
@@ -254,7 +254,7 @@ describe("WebUsbHidTransport", () => {
         const connect = await transport.connect(device);
 
         expect(connect).toStrictEqual(
-          Left(new UnknownDeviceError(new Error("Unknown device fake"))),
+          Left(new UnknownDeviceError("Unknown device fake")),
         );
       });
 
@@ -376,11 +376,7 @@ describe("WebUsbHidTransport", () => {
         });
 
         expect(disconnect).toStrictEqual(
-          Left(
-            new UnknownDeviceError(
-              new Error(`Unknown device ${connectedDevice.id}`),
-            ),
-          ),
+          Left(new UnknownDeviceError(`Unknown device ${connectedDevice.id}`)),
         );
       });