Investigate tech debt and address proposed best practices

[kickloop]

Copied as a backup

+1 for switching to yarn 💪

Regarding tech debt - we had a meeting with frontend guys and they pointed out:

• I18n integration - to avoid strings that are in many places duplicated (and gradually migrate them to some kind of application content storage).

• Unification of consts (currently application have checks of types to string eg. https://github.com/IntersectMBO/govtool/blob/f66591ab7156fe80996f5addf2de8356463365f3/src/vva-fe/src/context/wallet.tsx#L337C18-L337C18).

• Inline styles and duplicate components if there are any (needs investigation).

• Eslint, tsc, husky to have the unified code style and checks on commit.

• Wallet refactor - 1.2k of lines seems to be impossible to refactor at once but as it is one of the most crucial parts of the application I think that we should take care of designing the architecture for that module and again - gradually improve that file to increase the readability and maintainability.

• Also - @JanJaroszczak provided [#81] configure unit tests with vitest #58 with initial unit tests that are also a good starting point for any other unit tests that might be added to github actions.

[kickloop]

@MSzalowski @JanJaroszczak Copying here so that we can address the items and figure out next steps

cc @Ryun1

[placek]

From the infrastructure side:

1. We need to figure out the Nix configuration for all the modules.
   At the current situation we have the Nix configuration properly working for backend, but I'm not sure we have that for frontend. Other modules also requires proper development environment. We are about to incorporate nix flakes solution from @johnalotoski and we need to ensure it's operational.
2. We need to optimize CI/CD.
   Currently deployment lasts for circa 30min or more because we are building backend application with clean cabal build without caching. We should utilize Nix configuration and some cache to optimize that process to only compile the backend sourcecode instead of building all dependencies each time the deploy is triggered. This is dependent of the previous step and will significantly shorten the build process and testing.
3. The CI/CD workflows has to be cleaned up and fixed.
   On each PR the pipeline fails, we need to decide what we want to check on each build, in which order, how to optimize that to not slow dow development process, etc.
4. We probably need pre-commit hooks.
   As a CI pipeline optimization, as well as detecting problems early on, we want to have some pre-commit hooks.

[kickloop]

@placek and cc @MSzalowski You own this! :) Just get it done using the best judgement you have.

[placek]

Great, let's convert that into a discussion, so we leave a trace of our decissions on converting those ideas into tickets.

[placek]

Here is my proposal for the suggestions I've made above on how we should address the technical debt in DevOps field of competence.

Tasks for point 1.:

1. We need to figure out the Nix configuration for all the modules.

• Assess current Nix configuration state
  - Review the existing Nix configuration for the backend module.
  - Determine the status of the Nix configuration for the frontend and other modules.
  - Identify any gaps or discrepancies in the current setup.
• Incorporate Nix Flakes for project-wide configuration management
  - Integrate @johnalotoski's proposed Nix flakes solution (Adds a nix flake with the vva-be package #53), ensuring it is operational and meets project requirements.
  - Utilize Nix Flakes to encapsulate the entire project's Nix configurations as build targets.
  - Ensure the flake.nix file is properly set up to reference backend, frontend, infra, and deployment configurations.
• Source Nix configuration on the latest stable Nixpkgs version
  - Ensure that all Nix configurations are based on the latest stable version of nixpkgs.
  - Update any outdated Nix packages or configurations to align with the latest stable release.
• Develop Nix configuration for frontend
  - Create a Nix configuration for the frontend module that mirrors the setup and dependencies required.
  - Define development environments explicitly, including all necessary dependencies and toolchains.
• Refine backend Nix configuration
  - Review and refine the existing backend Nix configuration to ensure it meets current project requirements.
  - Explicitly define the backend development environment, including dependencies, toolchains, and any specific version requirements.
• Adjust Nix configuration for docker images creation
  - Create Nix expressions that define Docker images for the backend, frontend, and any other necessary services.
  - Ensure Docker images are optimized for size and build efficiency, incorporating best practices for layer caching.
• Establish Nix configurations for infrastructure and deployment
  - Review Nix configurations for infrastructure setup and deployment processes.
  - Include specifics for cloud resources, networking configurations, storage, and any other infrastructure components.
  - Ensure deployment configurations include necessary scripts and commands for automated deployments.
• Documentation and knowledge sharing
  - Ensure documentation of all Nix configurations mentioned above, including the rationale behind specific decisions and configurations.
  - Share knowledge and documentation with the development team to ensure everyone is up to speed with the Nix setup.
  - Provide training or workshops if necessary to help team members become proficient with Nix.
• Review and testing
  - Conduct thorough testing of all Nix configurations to ensure they work as expected across different environments.
  - Review configurations with the development team and stakeholders to gather feedback and make adjustments as needed.
• Continuous improvement
  - Establish a process for continuously reviewing and improving the Nix configurations as project requirements evolve.

Tasks for point 2.:

2. We need to optimize CI/CD.

• Incorporate Nix-based docker images creation within the deployment process.
  - Move as much deployment configuration as possible from imperative, GNU Make driven scripts to declarative, Nix driven statements.
• Implement Nix cache for efficient builds
  - Set up a Nix cache to speed up build times and improve developer productivity.
• Tune Nix configurations for CI/CD integration
  - Adapt Nix configurations to be compatible with GitHub Actions workflows.
  - Create specific CI/CD pipelines that leverage Nix for building, testing, and deploying applications.
  - Ensure pipelines are optimized for performance and reliability.
• Continuous improvement
  - Monitor the performance and efficiency of the CI/CD pipelines to identify opportunities for optimization.