tests are good

main.go

@@ -45,13 +45,33 @@ func (h Handler) serveHTTP(w http.ResponseWriter, r *http.Request) error {
 		return err
 	}
 
+	var duplicate int
+	if err := h.idempotency.QueryRowContext(r.Context(), `SELECT 1 FROM payloads WHERE payload=$1;`, b).Scan(&duplicate); err != sql.ErrNoRows && err != nil {
+		log.Println("!", err)
+	} else if duplicate > 0 {
+		log.Println("+")
+		return nil
+	}
+
+	if err := h.prune(time.Now().Add(-1 * time.Hour * 24 * 7)); err != nil {
+		log.Println("!", err)
+	}
+
 	resp, err := proxy(h.target, r, io.NopCloser(bytes.NewReader(b)))
 	if err != nil {
 		return err
 	}
 	defer resp.Body.Close()
 
-	return forward(w, resp)
+	if err := forward(w, resp); err != nil {
+		return err
+	}
+
+	if _, err := h.idempotency.ExecContext(r.Context(), `INSERT INTO payloads (ts, payload) VALUES ($1, $2);`, time.Now(), b); err != nil {
+		log.Println("!", err)
+	}
+
+	return nil
 }
 
 func main() {
@@ -63,40 +83,47 @@ func main() {
 	if err := fs.Parse(os.Args[1:]); err != nil {
 		panic(err)
 	}
+	if err := run(*p, *t, *y, *db); err != nil {
+		panic(err)
+	}
+}
 
-	db, err := sql.Open("sqlite", *db)
+func run(p int, t string, y string, db string) error {
+	idempotency, err := sql.Open("sqlite", db)
 	if err != nil {
-		panic(err)
+		return err
 	}
-	defer db.Close()
-	if err := db.PingContext(context.Background()); err != nil {
-		panic(err)
+	defer idempotency.Close()
+	if err := idempotency.PingContext(context.Background()); err != nil {
+		return err
+	} else if _, err := idempotency.ExecContext(context.Background(), `CREATE TABLE IF NOT EXISTS payloads (payload TEXT, ts TIMESTAMP NOT NULL)`); err != nil {
+		return err
 	}
 
-	tmpl, err := template.New("").Parse(*t)
+	tmpl, err := template.New("").Parse(t)
 	if err != nil {
-		panic(err)
+		return err
 	}
 
-	u, err := url.Parse(*y)
+	u, err := url.Parse(y)
 	if err != nil {
-		panic(err)
+		return err
 	}
 
-	h := Handler{tmpl: tmpl, target: u, idempotency: db}
-	log.Println("listening on", *p)
-	if err := http.ListenAndServe(":"+strconv.Itoa(*p), h); err != nil {
-		panic(err)
-	}
+	h := Handler{tmpl: tmpl, target: u, idempotency: idempotency}
+	log.Println("listening on", p)
+	return http.ListenAndServe(":"+strconv.Itoa(p), h)
 }
 
 func adapt(r io.Reader, tmpl *template.Template) ([]byte, error) {
 	b, _ := io.ReadAll(io.LimitReader(r, 1024*1024))
 	var v interface{}
 	buff := bytes.NewBuffer(nil)
-	if err := json.Unmarshal(b, &v); err != nil {
+	if len(b) == 0 {
+	} else if err := json.Unmarshal(b, &v); err != nil {
 		return nil, err
-	} else if err := tmpl.Execute(buff, v); err != nil {
+	}
+	if err := tmpl.Execute(buff, v); err != nil {
 		return nil, err
 	}
 	log.Printf("%s => %s", b, buff.Bytes())
@@ -135,3 +162,17 @@ func forward(w http.ResponseWriter, resp *http.Response) error {
 	io.Copy(w, resp.Body)
 	return nil
 }
+
+func (h Handler) prune(ts time.Time) error {
+	result, err := h.idempotency.ExecContext(context.Background(), `DELETE FROM payloads WHERE ts < $1;`, ts)
+	if err != nil {
+		return err
+	}
+
+	rows, _ := result.RowsAffected()
+	if rows > 1 {
+		log.Println("-", rows)
+	}
+
+	return nil
+}