Finish Criteria:

1. Identify Affected Projects:
   Develop a script capable of determining which projects have been modified based on the staged files in a Git repository.
   Lint Checks for Affected Projects:

2. Implement linting checks specifically tailored for the identified affected projects.
   Ensure that the linting process provides meaningful feedback on code quality and adherence to coding standards.

3. Unit Tests for Affected Projects:
   Develop a mechanism to execute unit tests selectively for the identified affected projects.
   Verify that the unit tests cover essential functionality and ensure code reliability.

4. Build Checks for Affected Projects:
   Design a process to run build checks tailored for the identified affected projects.
   Ensure the build process validates code integrity and compatibility.

5. Commit Permission Handling:
   Configure the script to permit a commit only if the lint checks, unit tests, and build checks for affected projects pass successfully.
   Enforce a rule that prohibits a commit if any of the previous commands fail.

6. TypeScript Implementation:
   Implement the script using TypeScript as the primary language for enhanced type safety and maintainability.
   Leverage TypeScript features and benefits for a more robust implementation.

7. Unit Tests:
   Develop a comprehensive set of unit tests for the script to validate its functionality and ensure future maintainability.
   Cover key scenarios, including positive and negative test cases.

Technology Stack:

• Husky:
  Utilize Husky to run scripts before or after Git commit actions, providing a convenient way to integrate the custom script seamlessly into the workflow.

• TypeScript:
  Develop the script using TypeScript to take advantage of its static typing and modern language features.

• Nx Lib Directory:
  Leverage Nx for efficient monorepo management, specifically focusing on the lib directory for organizing and structuring codÏ

Login Workflow Test:

Technologies: Formik, Material-UI, Yup

Validate user input for the login process using the specified technologies.

Display the following error messages based on user actions:

a. If the user attempts to login without entering an email, prompt with "Please enter your email" error.

b. If the user attempts to login without entering a password, display "Please enter your password" error.

c. Validate the email input, and if it is found to be invalid, show an error message stating, "Please enter a valid email address."

d. In case of an incorrect email or password, provide an error message indicating, "Please enter correct email or password."

Implement navigation behavior:

a. If the user clicks on the sign-up button, smoothly navigate to the sign-up page.

Ensure that the test thoroughly covers these scenarios to validate the login workflow.

Task Definition: Setting up MongoDB Connection in Node.js Backend

Finish Criteria:

1. Database Creation: Ensure the creation of a single MongoDB database.
2. Server-Database Connection: Establish a connection between the Node.js backend server and the MongoDB database using Mongoose.
3. Success Message: Print the message "Database connected successfully" upon the successful establishment of the server-database connection.

Technology Stack:

• MongoDB: Utilize MongoDB as the chosen NoSQL database solution.
• Mongoose: Employ the Mongoose package in Node.js to effectively manage interactions with MongoDB.
• dotenv (env): Implement the dotenv package to securely store and manage environment variables, especially for sensitive information like database connection details.

Implementation Guidelines:

1. Use the mongoose.connect method to initiate a connection to the MongoDB database.
2. Implement event listeners for various connection states (e.g., connected, error, disconnected).
3. Upon a successful connection, log a message indicating "Database connected successfully."
4. Implement graceful shutdown mechanisms to handle application termination and close the database connection appropriately.
5. Implement unit test and display code coverage

Select Currency User Workflow:

Technology Stack: Material UI
Component: Stepper

Implement the currency selection feature using Material UI Stepper component.

Set the default selected currency to MNT.

Validate user input for cash balance:

a. If the user does not enter their cash balance, display an error message stating, "Please enter your cash balance."

b. If the user enters text instead of a numerical value, show an error message saying, "Please enter a valid number."

Utilize E2E testing to ensure end-to-end functionality:

a. Confirm that the default selected currency is MNT.

b. Validate the error message display when the user doesn't enter their cash balance.

c. Verify the error message display when the user enters text instead of a number for the cash balance.

d. Test the navigation behavior:

When the user clicks on the "Go to Dashboard" button, ensure a smooth navigation to the dashboard page.
Thoroughly document and execute the E2E tests to validate the entire workflow.

Ensure that the E2E tests cover the specified scenarios and provide comprehensive coverage for the "Select Currency" user workflow.

Finish Criteria:

1. "Invalid Input" Error Handling:

   • Implement functionality to return an "invalid input" error if any of the required fields (name, password, or email) is not provided during user creation.

2. "User Creation Success" Message:

   • Develop a mechanism to return a "User creation success" message if the user is successfully created with the provided information.

3. Unit Test with 100% Code Coverage:

   • Write comprehensive unit tests for the user creation logic using Jest to ensure its correctness and reliability.
   • Aim for 100% code coverage to validate that all code paths are thoroughly tested.

Tech Stack:

• MongoDB:

  • Utilize MongoDB as the database to store user information and manage user creation.

• Typescript:

  • Develop the user creation logic using TypeScript for enhanced type safety, maintainability, and code readability.

• Jest:

  • Leverage Jest as the testing framework for writing unit tests to ensure the correctness of the user creation logic.

• GraphQL:

  • Use GraphQL for defining and querying APIs, including the resolver for user creation.

Implementation Guidelines:

• Implement validation checks to handle "invalid input" scenarios for missing or incorrect user creation data.
• Ensure the creation of the user in the MongoDB database and return the appropriate success message.
• Write comprehensive unit tests covering both positive and negative scenarios for the user creation resolver.
• Strive for 100% code coverage to guarantee thorough testing of the user creation logic.

Data model