Basic DB design + Order processing API

.gitignore

@@ -0,0 +1,4 @@
+tmp/
+.env
+
+coverage.out

README.md

@@ -7,8 +7,8 @@ A fun implementation of an asset exchange using Go. I am mostly doing this to le
 - [x] Handle partial fills.
 - [x] Handle market orders.
 - [x] Handle multiple assets.
-- [ ] Create an API layer to handle orders from customers (net/http).
+- [x] Create an API layer to handle orders from customers (net/http).
 - [ ] Simulate large order flow and experiment with concurrency (Channels + Goroutines).
 - [ ] Expose orderbook using websockets.
 - [ ] Simple UI to showcase project.
-- [x] Maintain 80%+ code coverage.
+- [ ] Maintain 80%+ code coverage.

cmd/seed/main.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"log"
+	"time"
+
+	_ "github.com/lib/pq"
+
+	"exchange/internal/db"
+)
+
+type Pair struct {
+	Ticker string
+	Name   string
+}
+
+func main() {
+	connStr := "postgresql://postgres:postgres@localhost:5432/testdb?sslmode=disable"
+	database, err := sql.Open("postgres", connStr)
+	if err != nil {
+		log.Fatalf("could not connect to db: %v", err)
+	}
+	queries := db.New(database)
+
+	log.Print("seeding database...")
+
+	// Example seeding assets
+	assets := []Pair{
+		{Ticker: "BTC", Name: "Bitcoin"},
+		{Ticker: "ETH", Name: "Ethereum"},
+		{Ticker: "LINK", Name: "Chainlink"},
+		{Ticker: "MADT", Name: "Tokenized MAD"},
+	}
+
+	ctx := context.Background()
+
+	for _, asset := range assets {
+		_, err := queries.CreateAsset(ctx, db.CreateAssetParams{
+			AssetName: asset.Name,
+			Ticker:    asset.Ticker,
+		})
+		if err != nil {
+			log.Printf("error seeding asset %s: %v", asset.Ticker, err)
+		} else {
+			log.Printf("seeded asset: %s", asset.Ticker)
+		}
+	}
+
+	queries.CreateUser(ctx, db.CreateUserParams{
+		FirstName: "Imad",
+		LastName:  "Archid",
+		Dob:       time.Now(),
+		Balance:   10000,
+		Email:     "imad@exchange.co",
+	})
+
+	log.Println("done.")
+}

docker-compose.yml

@@ -0,0 +1,15 @@
+services:
+  postgres:
+    image: postgres:16-alpine
+    container_name: test_postgres
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: testdb
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5

go.mod

@@ -3,3 +3,8 @@ module exchange
 go 1.24.2
 
 require github.com/google/uuid v1.6.0
+
+require (
+	github.com/go-chi/chi/v5 v5.2.1 // indirect
+	github.com/lib/pq v1.10.9 // indirect
+)

go.sum

@@ -1,2 +1,6 @@
+github.com/go-chi/chi/v5 v5.2.1 h1:KOIHODQj58PmL80G2Eak4WdvUzjSJSm0vG72crDCqb8=
+github.com/go-chi/chi/v5 v5.2.1/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=

internal/api/handler/asset.go

@@ -0,0 +1,23 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+func (h *Handler) GetAssets(w http.ResponseWriter, r *http.Request) {
+	assets, err := h.Queries.GetAllAssets(r.Context())
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		json.NewEncoder(w).Encode(ErrorResponse{
+			Code:    "ASSET_RETRIEVAL_FAILED",
+			Message: "Failed to retrieve assets",
+		})
+		fmt.Print(err)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(assets)
+}

internal/api/handler/order.go

@@ -0,0 +1,92 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+
+	"exchange/internal/db"
+	"exchange/internal/order"
+	"exchange/internal/orderbook"
+	"exchange/internal/types"
+
+	"github.com/google/uuid"
+)
+
+type OrderRequest struct {
+	Amount    int32           `json:"amount"`
+	Price     float64         `json:"price"`
+	Side      types.Side      `json:"side"`
+	OrderType types.OrderType `json:"order_type"`
+	Ticker    string          `json:"ticker"`
+}
+
+type ErrorResponse struct {
+	Code    string `json:"error"`
+	Message string `json:"message"`
+}
+
+type Handler struct {
+	Queries      *db.Queries
+	OrderBooks   map[string]*orderbook.OrderBook
+	ValidTickers map[string]struct{}
+}
+
+func (h *Handler) SubmitOrder(w http.ResponseWriter, r *http.Request) {
+	var req OrderRequest
+
+	err := json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(ErrorResponse{
+			Code:    "INVALID_REQUEST_BODY",
+			Message: "Failed to decode request body",
+		})
+		return
+	}
+
+	s := "6d28e047-27c2-457a-9c4f-d68af05d6c8e"
+	id, err := uuid.Parse(s)
+	if err != nil {
+		log.Fatal("Invalid UUID:", err)
+	}
+
+	order := order.NewOrder(req.Price, req.Amount, db.OrderSideType(req.Side), db.OrderType(req.OrderType), req.Ticker, id)
+	if order.IsValid() {
+		status := h.OrderBooks[req.Ticker].Submit(order, h.Queries)
+		if status {
+			w.WriteHeader(http.StatusCreated)
+			json.NewEncoder(w).Encode(order)
+		} else {
+			w.WriteHeader(http.StatusBadRequest)
+			json.NewEncoder(w).Encode(ErrorResponse{
+				Code:    "ORDERBOOK_SUBMISSION_FAILED",
+				Message: "Failed to submit order to orderbook",
+			})
+		}
+
+	} else {
+		w.WriteHeader(http.StatusBadRequest)
+		json.NewEncoder(w).Encode(ErrorResponse{
+			Code:    "ORDER_NOT_VALID",
+			Message: "Order is not valid",
+		})
+	}
+}
+
+func (h *Handler) GetOrders(w http.ResponseWriter, r *http.Request) {
+	orders, err := h.Queries.GetAllOrders(r.Context())
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		json.NewEncoder(w).Encode(ErrorResponse{
+			Code:    "ORDER_RETRIEVAL_FAILED",
+			Message: "Failed to retrieve orders",
+		})
+		fmt.Print(err)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(orders)
+}

internal/api/handler/transaction.go

@@ -0,0 +1,39 @@
+package handler
+
+import (
+	"context"
+	"exchange/internal/db"
+	"exchange/internal/events"
+	"fmt"
+)
+
+func StartTransactionPersistenceWorker(queries *db.Queries) {
+	for event := range events.TransactionEventChan {
+
+		_, err := queries.CreateTransaction(context.Background(), db.CreateTransactionParams{
+			BuyerOrder:  event.BuyerOrder.ID,
+			SellerOrder: event.SellerOrder.ID,
+			Price:       event.Price,
+			Amount:      event.Amount,
+			Asset:       event.Asset,
+			CreatedAt:   event.Timestamp,
+		})
+
+		if err == nil {
+			fmt.Print("Buyer: ", event.BuyerOrder, "\n")
+			queries.UpdateOrderStatus(context.Background(), db.UpdateOrderStatusParams{
+				ID:          event.BuyerOrder.ID,
+				OrderStatus: event.BuyerOrder.Status,
+			})
+			fmt.Print("Seller: ", event.SellerOrder, "\n")
+
+			queries.UpdateOrderStatus(context.Background(), db.UpdateOrderStatusParams{
+				ID:          event.SellerOrder.ID,
+				OrderStatus: event.SellerOrder.Status,
+			})
+		} else {
+			fmt.Print(err)
+		}
+
+	}
+}

internal/api/middlewares/json_response.go

@@ -0,0 +1,10 @@
+package middlewares
+
+import "net/http"
+
+func JSONMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		next.ServeHTTP(w, r)
+	})
+}

internal/api/router/router.go

@@ -0,0 +1,35 @@
+package router
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"exchange/internal/api/handler"
+	"exchange/internal/api/middlewares"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+func NewRouter(h *handler.Handler) http.Handler {
+	r := chi.NewRouter()
+
+	r.Use(middleware.Logger)
+	r.Use(middlewares.JSONMiddleware)
+
+	// Default route
+	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		json.NewEncoder(w).Encode(map[string]string{
+			"message": "it works",
+		})
+	})
+
+	// Orders route
+	r.Post("/orders", h.SubmitOrder)
+	r.Get("/orders", h.GetOrders)
+
+	// Assets route
+	r.Get("/assets", h.GetAssets)
+
+	return r
+}