1. CRUD

package store.account;

import java.util.List;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;

@FeignClient(name = "account", url = "http://account:8080")
public interface AccountController {

    @PostMapping("/account")
    public ResponseEntity<AccountOut> create(
        @RequestBody AccountIn accountIn
    );

    @GetMapping("/account")
    public ResponseEntity<List<AccountOut>> findAll();

    @PostMapping("/account/login")
    public ResponseEntity<AccountOut> findByEmailAndPassword(
        @RequestBody AccountIn accountIn
    );

    @GetMapping("/account/whoami")
    public ResponseEntity<AccountOut> whoami(
        @RequestHeader(value = "id-account", required = true) String idAccount
    );

}

package store.account;

import lombok.Builder;
import lombok.experimental.Accessors;

@Builder @Accessors(fluent = true)
public record AccountIn(
    String name,
    String email,
    String password
) {

}

package store.account;

import lombok.Builder;
import lombok.experimental.Accessors;

@Builder @Accessors(fluent = true)
public record AccountOut(
    String id,
    String name,
    String email
) {
}

package store.account;

import java.util.Date;

import lombok.Builder;
import lombok.Data;
import lombok.experimental.Accessors;

@Builder
@Data @Accessors(fluent = true)
public class Account {

    private String id;
    private String name;
    private String email;
    private String password;
    private String sha256;
    private Date birthdate;
    private Date creation;

}

package store.account;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AccountApplication {

    public static void main(String[] args) {
        SpringApplication.run(AccountApplication.class, args);
    }

}

package store.account;

import java.util.Date;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.experimental.Accessors;

@Entity
@Table(name = "account")
@Setter @Accessors(fluent = true)
@NoArgsConstructor
public class AccountModel {

    @Id
    @Column(name = "id_account")
    @GeneratedValue(strategy = GenerationType.UUID)
    private String id;

    @Column(name = "tx_name")
    private String name;

    @Column(name = "tx_email")
    private String email;

    @Column(name = "tx_sha256")
    private String sha256;

    @Column(name = "dt_birthdate")
    private Date birthdate;

    @Column(name = "dt_creation")
    private Date creation;

    public AccountModel(Account a) {
        this.id = a.id();
        this.name = a.name();
        this.email = a.email();
        this.sha256 = a.sha256();
        this.birthdate = a.birthdate();
        this.creation = a.creation();
    }

    public Account to() {
        return Account.builder()
            .id(this.id)
            .name(this.name)
            .email(this.email)
            .sha256(this.sha256)
            .birthdate(this.birthdate)
            .creation(this.creation)
            .build();
        }

}

package store.account;

public class AccountParser {

    public static Account to(AccountIn in) {
        return in == null ? null :
            Account.builder()
                .name(in.name())
                .email(in.email())
                .password(in.password())
                .build();
    }

    public static AccountOut to(Account a) {
        return a == null ? null :
            AccountOut.builder()
                .id(a.id())
                .name(a.name())
                .email(a.email())
                .build();
    }

}

package store.account;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;


/*
 * https://docs.spring.io/spring-data/jpa/reference/jpa/query-methods.html
 */

@Repository
public interface AccountRepository extends CrudRepository<AccountModel, String> {

    public AccountModel findByEmailAndSha256(String email, String sha256);

}

package store.account;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AccountResource implements AccountController {

    @Autowired
    private AccountService accountService;

    @Override
    public ResponseEntity<AccountOut> create(AccountIn accountIn) {
        Account created = accountService.create(AccountParser.to(accountIn));
        return ResponseEntity.ok().body(AccountParser.to(created));
    }

    @Override
    public ResponseEntity<List<AccountOut>> findAll() {
        return ResponseEntity
            .ok()
            .body(accountService.findAll().stream().map(AccountParser::to).toList());
    }

    @Override
    public ResponseEntity<AccountOut> findByEmailAndPassword(AccountIn accountIn) {
        Account account = accountService.findByEmailAndPassword(
            accountIn.email(),
            accountIn.password()
        );
        return ResponseEntity
            .ok()
            .body(AccountParser.to(account));
    }

    @Override
    public ResponseEntity<AccountOut> whoami(String idAccount) {
        return ResponseEntity
            .ok()
            .body(AccountParser.to(accountService.findById(idAccount)));
    }

}

package store.account;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Date;
import java.util.List;
import java.util.stream.StreamSupport;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;

@Service
public class AccountService {

    @Autowired
    private AccountRepository accountRepository;

    public Account findById(String id) {
        return accountRepository.findById(id).get().to();
    }

    public Account create(Account account) {
        final String pass = account.password().trim();
        if (pass.length() < 8) {
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Password too short!");
        }
        account.sha256(calcHash(pass));
        account.creation(new Date());
        return accountRepository.save(new AccountModel(account)).to();
    }

    public Account findByEmailAndPassword(String email, String password) {
        final String sha256 = calcHash(password);
        AccountModel m  = accountRepository.findByEmailAndSha256(email, sha256);
        return m == null ? null : m.to();
    }

    public List<Account> findAll() {
        return StreamSupport
            .stream(accountRepository.findAll().spliterator(), false)
            .map(AccountModel::to)
            .toList();
    }

    /*
     * A reference to implement a nice password's hash
     * https://github.com/ByteByteGoHq/system-design-101/tree/main?tab=readme-ov-file#how-to-store-passwords-safely-in-the-database-and-how-to-validate-a-password
     */
    private String calcHash(String value) {
        try {
            MessageDigest digester = MessageDigest.getInstance("SHA-256");
            byte[] hash = digester.digest(value.getBytes(StandardCharsets.UTF_8));
            String encoded = Base64.getEncoder().encodeToString(hash);
            return encoded;
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

}