Simple Bank

This repository contains the codes of the Backend master class course by TECH SCHOOL.

In this backend master class, we’re going to learn everything about how to design, develop, and deploy a complete backend system from scratch using Golang, PostgreSQL, and Docker.

Course videos

Lecture #1: Design DB schema and generate SQL code with dbdiagram.io
Lecture #2: Install & use Docker + Postgres + TablePlus to create DB schema
Lecture #3: How to write & run database migration in Golang
Lecture #4: Generate CRUD Golang code from SQL | Compare db/sql, gorm, sqlx & sqlc
Lecture #5: Write unit tests for database CRUD with random data in Golang
Lecture #6: A clean way to implement database transaction in Golang
Lecture #7: DB transaction lock & How to handle deadlock in Golang
Lecture #8: How to avoid deadlock in DB transaction? Queries order matters!
Lecture #9: Deeply understand transaction isolation levels & read phenomena in MySQL & PostgreSQL
Lecture #10: Setup Github Actions for Golang + Postgres to run automated tests
Lecture #11: Implement RESTful HTTP API in Go using Gin
Lecture #12: Load config from file & environment variables in Go with Viper
Lecture #13: Mock DB for testing HTTP API in Go and achieve 100% coverage
Lecture #14: Implement transfer money API with a custom params validator
Lecture #15: Add users table with unique & foreign key constraints in PostgreSQL
Lecture #16: How to handle DB errors in Golang correctly
Lecture #17: How to securely store passwords? Hash password in Go with Bcrypt!
Lecture #18: How to write stronger unit tests with a custom gomock matcher
Lecture #19: Why PASETO is better than JWT for token-based authentication?
Lecture #20: How to create and verify JWT & PASETO token in Golang
Lecture #21: Implement login user API that returns PASETO or JWT access token in Go
Lecture #22: Implement authentication middleware and authorization rules in Golang using Gin
Lecture #23: Build a minimal Golang Docker image with a multistage Dockerfile
Lecture #24: How to use docker network to connect 2 stand-alone containers
Lecture #25: How to write docker-compose file and control service start-up orders with wait-for.sh

Simple bank service

The service that we’re going to build is a simple bank. It will provide APIs for the frontend to do following things:

Create and manage bank accounts, which are composed of owner’s name, balance, and currency.
Record all balance changes to each of the account. So every time some money is added to or subtracted from the account, an account entry record will be created.
Perform a money transfer between 2 accounts. This should happen within a transaction, so that either both accounts’ balance are updated successfully or none of them are.

Setup local development

Install tools

Docker desktop
TablePlus
Golang
Homebrew
Migrate
```
brew install golang-migrate
```
Sqlc
```
brew install sqlc
```

Setup infrastructure

Start postgres container:
```
make postgres
```
Create simple_bank database:
```
make createdb
```
Run db migration up all versions:
```
make migrateup
```
Run db migration up 1 version:
```
make migrateup1
```
Run db migration down all versions:
```
make migratedown
```
Run db migration down 1 version:
```
make migratedown1
```

How to generate code

Generate SQL CRUD with sqlc:
```
make sqlc
```
Generate DB mock with gomock:
```
make mock
```

Create a new db migration:

migrate create -ext sql -dir db/migration -seq <migration_name>

How to run

Run server:
```
make server
```
Run test:
```
make test
```

SmartsYoung/simplebank