feat: simple validation and some minor changes

src/modules/account/wallet.ts

@@ -14,17 +14,20 @@ export class Wallet {
   }
 
   /**
-   * This async function adds a wallet address to the user's account and returns a response.
-   * @param {string} wallet - The `add` function is an asynchronous function that takes a `wallet`
-   * parameter of type string. This function sends a POST request to create a new wallet for the current
-   * account. The wallet address is provided in the `wallet` parameter and is sent in the request body.
+   * The `add` function in TypeScript adds a new wallet address to the user's account asynchronously.
+   * @param {string} address - The `add` function in the code snippet you provided is an asynchronous
+   * function that takes a `string` parameter called `address`. The function first checks if the
+   * `address` string is empty using a validation service method `isEmptyString(address)`. Then, it makes
+   * a POST request to a specific endpoint
    * @returns The `add` function is returning a `Promise` that resolves to a `MyAccountResponse` object.
    */
-  async add(wallet: string): Promise<MyAccountResponse> {
+
+  async add(address: string): Promise<MyAccountResponse> {
+    this.validationService.isEmptyString(address);
     const { data, error, response } = await this.client.POST(
       '/accounts/me/wallets',
       {
-        body: { address: wallet },
+        body: { address: address },
       },
     );
 
@@ -46,6 +49,8 @@ export class Wallet {
    * object.
    */
   async remove(address: string): Promise<MyAccountResponse> {
+    this.validationService.isEmptyString(address);
+
     const { data, error, response } = await this.client.DELETE(
       '/accounts/me/wallets/{address}',
       {

src/services/validator-service.ts

@@ -20,6 +20,25 @@ export class ValidationService {
     return true;
   }
 
+  /**
+   * The function checks if a string is empty or contains only whitespace.
+   * @param {string} value - The `value` parameter in the `isEmptyString` function is a string that you
+   * want to check for emptiness or containing only whitespace characters. The function will return
+   * `true` if the string is not empty or does not contain only whitespace characters, otherwise it will
+   * throw an error indicating that the string
+   * @returns The `isEmptyString` function is returning a boolean value, either `true` if the provided
+   * string is not empty or contains only whitespace, or it will throw an error if the string is empty or
+   * contains only whitespace.
+   */
+  public isEmptyString(value: string): boolean {
+    if (value.trim().length === 0) {
+      throw new Error(
+        'The provided string is empty or contains only whitespace',
+      );
+    }
+    return true;
+  }
+
   /**
    * The function `validateString` checks if a given string meets a minimum length requirement and
    * returns a boolean value accordingly.

test/data-model.test.ts

@@ -1,8 +1,8 @@
 import { ValidationService } from '../src/services/validator-service';
 import { GTWError } from '../src/helpers/custom-error';
 import { DataModel } from '../src/modules/data-model/data-model';
-import { Config, DataModelRequest } from '../src/common/types';
-import { mockClient, mockGet, mockPost, mockPut } from './stubs/common.stub';
+import { DataModelRequest } from '../src/common/types';
+import { mockClient, mockGet, mockPost } from './stubs/common.stub';
 import { routes } from '../src/common/routes';
 
 const mockValidationService = {} as ValidationService;

test/utils.test.ts

@@ -39,6 +39,17 @@ describe('UTILS VALIDATORS TESTING', () => {
     ).toThrow('f17ac10b-58cc-4372-a567 is not valid');
   });
 
+  it('isEmptyString validator', () => {
+    const result = validationService.isEmptyString('test pda');
+    expect(result).toBeDefined();
+    expect(() => validationService.isEmptyString('')).toThrow(
+      'The provided string is empty or contains only whitespace',
+    );
+    expect(() => validationService.isEmptyString('   ')).toThrow(
+      'The provided string is empty or contains only whitespace',
+    );
+  });
+
   it('string validator', () => {
     const result = validationService.validateString('test pda');
     expect(result).toBeDefined();