thiagobutignon/enrich-login-usecase-ai-generated.md

Last active May 16, 2024 17:16

Star () You must be signed in to star a gist
Fork () You must be signed in to fork a gist

Learn more about clone URLs
Clone this repository at <script src="https://gist.github.com/thiagobutignon/b20c9c4386a45d9ee7b019bf42fadb5a.js"></script>
Save thiagobutignon/b20c9c4386a45d9ee7b019bf42fadb5a to your computer and use it in GitHub Desktop.

Raw

enrich-login-usecase-ai-generated.md

import { HttpClient, HttpStatusCode } from '@/data/protocols'
import { InvalidCredentialError, UnexpectedError } from '@/domain/errors'

import { LoginUsecase } from '@/domain/usecases'

export class RemoteLogin implements LoginUsecase {
  constructor (
    private readonly url: string,
    private readonly httpClient: HttpClient<LoginUsecase.Result>
  ) {}

  async perform (params: LoginUsecase.Params): Promise<LoginUsecase.Result> {
    const httpResponse = await this.httpClient.request({
      url: this.url,
      method: 'post',
      body: params
    })

    switch (httpResponse.statusCode) {
      case HttpStatusCode.ok:
        return httpResponse.body
      case HttpStatusCode.unauthorized:
        throw new InvalidCredentialError()
      default:
        throw new UnexpectedError()
    }
  }
}

RemoteLogin Interface Documentation

Purpose and Intended Usage

The RemoteLogin interface is a implementation of the LoginUsecase protocol, responsible for performing login operations remotely using an HTTP client. This interface provides a way to authenticate users against a backend API.

Methods

`perform(params: LoginUsecase.Params)`

This method performs a login operation using the provided parameters (params). It takes in the necessary credentials and other required data to complete the authentication process.

Parameters:
- params: An object containing the login credentials and any additional information required for the authentication process.
Return Type: A promise resolving with the result of the login operation, as defined by the LoginUsecase.Result type.
Details:
- The method uses an HTTP client to send a POST request to the specified URL (this.url) with the provided parameters in the request body.
- It then checks the response status code and handles any errors accordingly.
- If the response status code is 200 (OK), it returns the response body as the result of the login operation.
- If the response status code is 401 (Unauthorized), it throws an InvalidCredentialError.
- For any other unexpected error, it throws a UnexpectedError.

Example Usage

import { RemoteLogin } from './remote-login';

const remoteLogin = new RemoteLogin('https://example.com/login', httpClient);
const params = { username: 'johnDoe', password: 'myPassword' };

try {
  const result = await remoteLogin.perform(params);
  console.log(result); // Login successful, result is the returned data
} catch (error) {
  if (error instanceof InvalidCredentialError) {
    console.error('Invalid credentials');
  } else {
    console.error('Unexpected error');
  }
}

Dependencies and Relationships

The RemoteLogin interface relies on:

@/data/protocols/HttpClient: An HTTP client implementation to send requests and receive responses.
@/domain/errors: A set of error types used for handling errors during the login process.
@/domain/usecases/LoginUsecase: The protocol defining the login operation, which this interface implements.

This interface is part of a larger codebase that may include other use cases and interfaces related to user authentication. Code Review Feedback

Overall, the code appears well-organized and follows established coding standards. However, there are some areas for improvement and suggestions for enhancement:

Variable Naming: The variable names (httpResponse, this.url, etc.) could be more descriptive to improve code readability.
Error Handling: While the error handling is robust, it might be beneficial to provide more specific error messages or logs to aid in debugging. Consider adding a log statement for each error type (e.g., console.error('Invalid credentials:', error)) to provide more context.
Consistent Coding Style: The code uses both camelCase and underscore notation for variable names. It's recommended to stick to one convention throughout the codebase for consistency.
Performance Optimization: Since the HTTP client is used to send a POST request, consider adding a timeout or retry mechanism to handle potential network issues or slow responses.
Scalability: The code does not seem to be optimized for scalability, as it uses synchronous HTTP requests and does not provide any caching mechanisms. Consider implementing asynchronous requests using async/await syntax and exploring caching libraries (e.g., Redis) for improved performance.
Documentation: While the interface documentation is informative, consider adding more details about the expected input types (params) and any specific requirements or constraints.

Suggestions

Implement a logging mechanism to track login attempts and errors. This will help with debugging and security auditing.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and any specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Code Smells

The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms (see suggestion 2).
The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.

Overall, the code is well-structured, but there are areas for improvement regarding variable naming, error handling, performance optimization, scalability, and documentation. The provided codebase employs several design patterns, including:

Interface Segregation Principle (ISP): The RemoteLogin interface segregates its methods into distinct protocols (perform) that can be easily extended or modified without affecting the rest of the system.
Dependency Injection: The constructor of the RemoteLogin class injects dependencies (HTTP client and URL) to decouple the implementation from the concrete classes.
Single Responsibility Principle (SRP): Each method in the perform interface has a single responsibility, which makes it easier to understand, test, and maintain.
Factory Method Pattern: The HTTP client is used as a factory to create requests and send them to the server.
Chain of Responsibility Pattern: The error handling mechanism (throwing specific error types) can be considered a simple implementation of this pattern.

These design patterns contribute to the codebase's structure, scalability, and maintainability. They help:

Decouple dependencies between classes
Improve extensibility and modifiability
Enhance readability and understandability
Simplify error handling and logging

To further improve the codebase, consider implementing additional design patterns or best practices, such as:

Observer Pattern: Implement a notification mechanism to track login attempts and errors.
Caching: Utilize caching libraries (e.g., Redis) to improve performance and scalability.
Async/Await Syntax: Refactor synchronous HTTP requests to use async/await syntax for improved responsiveness and scalability.
Error Handling Library: Integrate a more robust error handling library (e.g., @errors-js) to provide more informative error messages.

By employing these design patterns and best practices, the codebase can become more maintainable, scalable, and robust. Based on the provided code and documentation, I will conduct an assessment of the codebase to determine its alignment with the principles of clean architecture.

Domain Layer The RemoteLogin interface is part of the domain layer, which represents the business logic of the application. The interface defines the perform method, which is responsible for performing login operations using an HTTP client. This aligns well with the principles of clean architecture, as the interface is focused on a specific business capability and does not contain infrastructure or framework-specific code.

Infrastructure Layer The HTTP client (HttpClient) and URL (this.url) are injected into the RemoteLogin interface through its constructor. This decouples the implementation from the concrete classes, aligning with the principles of clean architecture. The use of dependency injection also helps to separate concerns between the domain layer (business logic) and the infrastructure layer (HTTP client).

Error Handling The code handles errors using a simple throw new Error() mechanism, which can be improved upon using more robust error handling mechanisms. This is an area for improvement, as clean architecture emphasizes the importance of separating concerns and handling errors in a way that is decoupled from the business logic.

Scalability and Performance The code does not seem to be optimized for scalability or performance. Synchronous HTTP requests can lead to bottlenecks and slow down the application. Implementing asynchronous requests using async/await syntax and exploring caching libraries (e.g., Redis) can improve performance and scalability.

Documentation The provided documentation is informative, but could be improved by adding more details about the expected input types (params) and any specific requirements or constraints. Clean architecture emphasizes the importance of clear and concise documentation to help developers understand the system.

Suggestions for Improvement

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and any specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Code Smells

The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.
The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.

Overall, the codebase aligns well with the principles of clean architecture in terms of separating concerns between the domain layer (business logic) and infrastructure layer (HTTP client). However, there are areas for improvement regarding error handling, scalability, and documentation. By addressing these issues, the codebase can become more maintainable, scalable, and robust. Here's my review of the SOLID principles:

Single Responsibility Principle (SRP): The RemoteLogin interface has a single responsibility, which is to perform login operations using an HTTP client. This aligns well with the SRP.

Open-Closed Principle (OCP): The interface is open for extension but closed for modification, as new login protocols can be added without modifying the existing code. However, the error handling mechanism could be improved upon by introducing a more robust error handling library.

Liskov Substitution Principle (LSP): The interface does not violate LSP, as it does not impose any constraints on its subclasses or methods that would prevent them from being used as substitutes for other instances of the same class or method.

Interface Segregation Principle (ISP): The interface is designed to be used by a single client, which is the HTTP client. It does not violate ISP, as it does not require multiple clients to use the same interface.

Dependency Inversion Principle (DIP): The interface depends on an abstraction (the HTTP client) rather than concrete implementations. This aligns well with DIP.

Overall, the codebase demonstrates good adherence to the SOLID principles, particularly in terms of separating concerns between the domain layer and infrastructure layer. However, there are areas for improvement regarding error handling and scalability. This is a comprehensive review of a codebase written in JavaScript that implements Behavior-Driven Development (BDD) practices and adheres to the SOLID principles. The reviewer provides suggestions for improvement, identifies code smells, and assesses the alignment with clean architecture principles.

Strengths:

Well-structured design patterns are employed, including Interface Segregation Principle (ISP), Dependency Injection, Single Responsibility Principle (SRP), Factory Method Pattern, and Chain of Responsibility Pattern.
The codebase demonstrates good adherence to SOLID principles, particularly in terms of separating concerns between the domain layer and infrastructure layer.

Weaknesses:

Error handling is not robust enough; a more robust error handling library could be used to provide more informative error messages.
Scalability and performance are not optimized; synchronous HTTP requests can lead to bottlenecks, and asynchronous requests using async/await syntax and caching libraries (e.g., Redis) could improve performance and scalability.
Documentation is informative but could be improved by adding more details about expected input types (params) and specific requirements or constraints.

Suggestions for Improvement:

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Code Smells:

The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.
The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.

Overall, the codebase demonstrates good adherence to SOLID principles and BDD practices, but there are areas for improvement regarding error handling, scalability, and documentation. By addressing these issues, the codebase can become more maintainable, scalable, and robust. This is a comprehensive review of a JavaScript codebase that implements Behavior-Driven Development (BDD) practices and adheres to SOLID principles. The reviewer provides suggestions for improvement, identifies code smells, and assesses the alignment with clean architecture principles.

Strengths:

Well-structured design patterns are employed, including Interface Segregation Principle (ISP), Dependency Injection, Single Responsibility Principle (SRP), Factory Method Pattern, and Chain of Responsibility Pattern.
The codebase demonstrates good adherence to SOLID principles, particularly in terms of separating concerns between the domain layer and infrastructure layer.

Weaknesses:

Error handling is not robust enough; a more robust error handling library could be used to provide more informative error messages.
Scalability and performance are not optimized; synchronous HTTP requests can lead to bottlenecks, and asynchronous requests using async/await syntax and caching libraries (e.g., Redis) could improve performance and scalability.
Documentation is informative but could be improved by adding more details about expected input types (params) and specific requirements or constraints.

Suggestions for Improvement:

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Code Smells:

The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.
The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.

Please let me know if you would like me to add or modify anything in this review. A comprehensive code review!

Here's my evaluation of the simplicity of the provided codebase:

Simplicity: The code is well-organized and easy to follow, with clear separation of concerns between the domain layer (business logic) and infrastructure layer (HTTP client). The interface RemoteLogin has a single responsibility, which makes it easy to understand its behavior and intended usage. However, the error handling mechanism could be improved upon using more robust error handling mechanisms.

As for the KISS principle, I'd say that the code is generally simple and straightforward, with no unnecessary complexity. But, as mentioned earlier, there are areas where improvement can be made, such as enhancing the interface documentation and exploring caching libraries or frameworks to improve performance and scalability.

Suggestions for Improvement:

Error handling: Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Documentation: Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Scalability and Performance: Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Code Smells:

The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.
The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.

Please let me know if you'd like me to add or modify anything in this review! I'd be happy to help!

The provided codebase adheres well to several SOLID principles:

Single Responsibility Principle (SRP): The interface RemoteLogin has a single responsibility, which makes it easy to understand its behavior and intended usage.
Interface Segregation Principle (ISP): The interface is designed with specific responsibilities in mind, making it easier for consumers to use the interface without being forced to implement methods they don't need.
Dependency Injection: The codebase separates concerns between the domain layer (business logic) and infrastructure layer (HTTP client), which makes it easier to test and maintain.

However, there are some areas where improvement can be made:

Error handling: The code uses throw new Error() for error handling, which is not very robust. Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Scalability and Performance: The codebase could benefit from asynchronous requests using async/await syntax and caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.
Documentation: While the interface documentation is informative, it could be improved by adding more details about expected input types (params) and specific requirements or constraints.

Suggestions for Improvement:

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Code Smells:

The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.
The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.

Please let me know if you'd like me to add or modify anything in this review! Based on the provided code review, I would give the adherence to DRY (Don't Repeat Yourself) principle a score of 8 out of 10.

The codebase demonstrates good separation of concerns between the domain layer and infrastructure layer, which is a key aspect of the DRY principle. The RemoteLogin interface has a single responsibility, making it easy to understand its behavior and intended usage. Additionally, the use of interfaces and dependency injection helps to decouple the domain logic from the infrastructure, which reduces duplication and makes the code more maintainable.

However, there are some areas where improvement can be made:

Error handling: The code uses throw new Error() for error handling, which is not very robust. Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Scalability and Performance: The codebase could benefit from asynchronous requests using async/await syntax and caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

To improve the adherence to DRY principles, I would suggest:

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

Overall, while there are some areas where improvement can be made, the codebase demonstrates good adherence to SOLID principles and BDD practices. By addressing these issues, the codebase can become more maintainable, scalable, and robust. I'd like to review your code review!

Code Quality: Your code review is well-structured and provides actionable suggestions for improvement. You've identified areas where the codebase can be strengthened, such as error handling, scalability, and documentation.

Suggestions: I appreciate the concrete suggestions you provided for improving the codebase, including implementing a logging mechanism, using a more robust error handling library, enhancing interface documentation, and exploring caching libraries or frameworks. These recommendations are specific and actionable, making it easier for developers to understand how to improve the codebase.

Code Smells: You've correctly identified two code smells: 1) throw new Error() can be improved upon using more robust error handling mechanisms, and 2) the perform method lacks documentation. This helps developers understand potential issues with the codebase and provides guidance on how to address them.

To further improve your code review:

Consider providing more specific examples or code snippets to illustrate how the suggested improvements could be implemented.
Provide a clear conclusion summarizing the key points and recommendations from the review.

Overall, your code review is well-written, informative, and provides actionable suggestions for improvement. It's easy to follow and understand, making it an excellent resource for developers looking to improve their codebase. I'd be happy to help!

Your comprehensive code review is well-organized, easy to follow, and provides actionable suggestions for improvement. You've identified areas where the codebase can be strengthened, such as error handling, scalability, and documentation.

Here are some specific suggestions I have:

Error Handling: While you mentioned using a more robust error handling library (e.g., @errors-js), it would be helpful to provide an example of how this could be implemented in the code review. For instance, you could demonstrate how to use a try-catch block with a custom error class.

Documentation: Your suggestion to enhance interface documentation by adding examples of valid input types (params) and specific requirements or constraints is excellent. To further improve documentation, consider providing an example of how the RemoteLogin interface should be used, including any specific parameters or values that need to be provided.

Scalability and Performance: Your recommendation to explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability is excellent. To further improve this suggestion, consider providing an example of how a caching library could be integrated into the codebase.

Code Smells: You've correctly identified two code smells: throw new Error() can be improved upon using more robust error handling mechanisms, and the perform method lacks documentation. This helps developers understand potential issues with the codebase and provides guidance on how to address them.

DRY Principle: Your review highlights the good adherence of the codebase to SOLID principles and BDD practices. You've also identified areas where improvement can be made, such as error handling and scalability, which is important for maintaining a DRY principle (Don't Repeat Yourself). To further improve this suggestion, consider providing an example of how the codebase could be refactored to reduce duplication.

Conclusion: Your code review provides a clear summary of the key points and recommendations from the review. It's easy to follow and understand, making it an excellent resource for developers looking to improve their codebase.

Overall, your code review is well-written, informative, and provides actionable suggestions for improvement. I think you're on the right track!

Please let me know if you have any questions or would like me to elaborate on any of these points! This looks like a comprehensive code review with specific suggestions for improvement. Here's a breakdown of the areas where performance optimizations can be made:

Error handling: The current error handling mechanism is not robust enough. Suggest using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Scalability and Performance: The codebase could benefit from asynchronous requests using async/await syntax and caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.
Documentation: While the interface documentation is informative, it could be improved by adding more details about expected input types (params) and specific requirements or constraints.

Some specific suggestions for improvement include:

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

The code review also identifies two code smells:

The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.
The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.

To further improve the code review, consider providing specific examples or code snippets to illustrate how the suggested improvements could be implemented. Additionally, provide a clear conclusion summarizing the key points and recommendations from the review.

Overall, this is a well-written, informative, and actionable code review that provides valuable insights for developers looking to improve their codebase. This appears to be a comprehensive code review with specific suggestions for improvement. Here's a breakdown of the areas where performance optimizations can be made:

Error handling: The current error handling mechanism is not robust enough. Suggest using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Scalability and Performance: The codebase could benefit from asynchronous requests using async/await syntax and caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.
Documentation: While the interface documentation is informative, it could be improved by adding more details about expected input types (params) and specific requirements or constraints.

Some specific suggestions for improvement include:

Implement a logging mechanism to track login attempts and errors.
Consider using a more robust error handling library (e.g., @errors-js) to provide more informative error messages.
Enhance the interface documentation by adding examples of valid input types (params) and specific requirements or constraints.
Explore caching libraries or frameworks (e.g., Redis, Memcached) to improve performance and scalability.

The code review also identifies two code smells:

The perform method is not explicitly documented with comments or JSDoc blocks, making it harder to understand its behavior and intended usage.
The code uses throw new Error() for error handling, which can be improved upon using more robust error handling mechanisms.

Overall, this is a well-written, informative, and actionable code review that provides valuable insights for developers looking to improve their codebase. Here's an example of how you could incorporate both offensive (Red Team) and defensive (Blue Team) strategies into snippets to illustrate how the suggested improvements could be implemented:

Error Handling:

// Original Code:
try {
  // Perform login operation
} catch (error) {
  console.error('Login failed:', error);
}

// Improved Code:
import { Errors } from '@errors-js';

try {
  // Perform login operation
} catch (error) {
  const customError = new Errors.LoginFailedError(error.message);
  console.error('Login failed:', customError);
}

Documentation:

// Original Interface Documentation:
/**
 * Performs a remote login operation.
 *
 * @param {string} username - The username to use for the login attempt.
 * @param {string} password - The password to use for the login attempt.
 */
async perform(username: string, password: string) {
  // Login logic
}

// Improved Interface Documentation:
/**
 * Performs a remote login operation.
 *
 * @param {string} username - The username to use for the login attempt (required).
 * @param {string} password - The password to use for the login attempt (required).
 * @example Usage: await RemoteLogin.perform('johnDoe', 'mySecretPassword');
 */
async perform(username: string, password: string) {
  // Login logic
}

Scalability and Performance:

// Original Code:
const loginResponse = await fetch('/login', {
  method: 'POST',
  body: JSON.stringify({ username, password }),
});

// Improved Code (with caching):
import { Cache } from 'redis';

const cache = new Cache();

async function performLogin(username, password) {
  const cachedResponse = await cache.get('login-response');
  if (cachedResponse) return cachedResponse;

  const loginResponse = await fetch('/login', {
    method: 'POST',
    body: JSON.stringify({ username, password }),
  });

  // Store the response in the cache
  await cache.set('login-response', loginResponse);

  return loginResponse;
}

Code Smells:

// Original Code (with code smell):
function performLogin(username, password) {
  if (!username || !password) throw new Error('Invalid credentials');

  // Login logic
}

// Improved Code:
function validateCredentials(username, password) {
  if (!username || !password) return 'Invalid credentials';
  // ... other validation logic ...
}

async function performLogin(username, password) {
  const validationResult = validateCredentials(username, password);
  if (validationResult) throw new Error(validationResult);

  // Login logic
}

Conclusion: In conclusion, this code review provides a comprehensive analysis of the provided codebase, highlighting areas for improvement and suggesting specific strategies for optimization. By incorporating both offensive (Red Team) and defensive (Blue Team) strategies into snippets, developers can effectively implement suggested improvements and maintain a high level of code quality.

Some key takeaways from this review include:

Improving error handling mechanisms to provide more informative error messages.
Enhancing documentation by adding examples and specific requirements for input parameters.
Implementing caching mechanisms to improve performance and scalability.
Addressing code smells by refactoring code to be more robust and maintainable.

Raw

initial-login-usecase-ai-generated.md

    import { HttpClient, HttpStatusCode } from '@/data/protocols'
import { InvalidCredentialError, UnexpectedError } from '@/domain/errors'

import { LoginUsecase } from '@/domain/usecases'

export class RemoteLogin implements LoginUsecase {
  constructor (
    private readonly url: string,
    private readonly httpClient: HttpClient<LoginUsecase.Result>
  ) {}

  async perform (params: LoginUsecase.Params): Promise<LoginUsecase.Result> {
    const httpResponse = await this.httpClient.request({
      url: this.url,
      method: 'post',
      body: params
    })

    switch (httpResponse.statusCode) {
      case HttpStatusCode.ok:
        return httpResponse.body
      case HttpStatusCode.unauthorized:
        throw new InvalidCredentialError()
      default:
        throw new UnexpectedError()
    }
  }
}

  