isl-api/main.go

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

	"forgejo.merr.is/annika/isl-api/Controllers"
	"forgejo.merr.is/annika/isl-api/Services"
	"forgejo.merr.is/annika/isl-api/sql/powerItem"
	"github.com/jackc/pgx/v4/pgxpool"
	"github.com/julienschmidt/httprouter"
	"github.com/spf13/viper"
)

var conf *EnvConfigs

func init() {
	setupConfig()
}

func main() {
	deps := dependencies{}
	deps.initializeDependencies()

	deps.router.HandlerFunc("GET", "/", index)

	fmt.Printf("Preparing to listen on `:%v`\n", conf.HttpPort)
	err := http.ListenAndServe(fmt.Sprintf(":%v", conf.HttpPort), deps.router)
	log.Fatal(err)
}

func setupConfig() {
	viper.AddConfigPath(".")
	viper.SetConfigName(".env")
	viper.SetConfigType("env")

	viper.SetEnvPrefix("isl_api")
	viper.AutomaticEnv()

	if err := viper.ReadInConfig(); err != nil {
		fmt.Printf("Error reading env file: %v\n", err)
	}

	if err := viper.Unmarshal(&conf); err != nil {
		log.Fatal(err)
	}
}

type dependencies struct {
	router              *httprouter.Router
	postgresConnection  *pgxpool.Pool
	context             context.Context
	powerItemQuerier    *powerItem.DBQuerier
	powerItemService    *Services.PowerItemService
	powerItemController *Controllers.PowerItemController
}

func (d *dependencies) initializeDependencies() error {
	var err error

	d.router = httprouter.New()
	d.router.GlobalOPTIONS = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("Access-Control-Request-Method") != "" {
			header := w.Header()
			header.Set("Access-Control-Allow-Methods", header.Get("Allow"))
			header.Set("Access-Control-Allow-Headers", "Cache-Control, Expires, Pragma")
			header.Set("Access-Control-Allow-Origin", "*")
		}
	})
	d.context = context.Background()
	d.postgresConnection, err = pgxpool.Connect(d.context, conf.ConnectionString)
	if err != nil {
		return err
	}
	d.powerItemQuerier = powerItem.NewQuerier(d.postgresConnection)
	d.powerItemService = Services.NewPowerItemService(d.powerItemQuerier)
	d.powerItemController = Controllers.NewPowerItemController(d.router, d.powerItemService)
	return nil
}

func MiddleCORS(next httprouter.Handle) httprouter.Handle {
	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
		w.Header().Set("Access-Control-Allow-Origin", "*")
		next(w, r, ps)
	}
}

func index(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Index")
}