Início rápido

mkdir loja && cd loja
go mod init loja
go get github.com/spolly-ao/spolly-payments-go@v0.1.0

mkdir loja && cd loja
npm init -y
npm install github:spolly-ao/spolly-payments-js#v0.1.0

// main.go: a loja mínima. Cria a sessão, recebe o webhook, mostra o regresso.
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"sync"

	spolly "github.com/spolly-ao/spolly-payments-go"
	"github.com/spolly-ao/spolly-payments-go/webhook"
)

func main() {
	var opcoes []spolly.Option
	if u := os.Getenv("SPOLLY_API_URL"); u != "" {
		opcoes = append(opcoes, spolly.WithBaseURL(u))
	}
	cliente := spolly.NewClient(os.Getenv("SPOLLY_SECRET_KEY"), opcoes...)
	verificador := webhook.Verifier{Secrets: []string{os.Getenv("SPOLLY_WEBHOOK_SECRET")}}
	loja := os.Getenv("LOJA_URL") // o endereço público desta loja, por exemplo o do túnel

	var mu sync.Mutex
	pagas := map[string]bool{}    // na tua loja, é a tabela das encomendas
	tratados := map[string]bool{} // os eventos já tratados, pelo id

	// A página da loja, com o botão de pagar.
	http.HandleFunc("GET /{$}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		fmt.Fprint(w, `<form method="post" action="/comprar">
  <input name="encomenda" value="1042"> <button>Pagar 15.000,00 Kz</button>
</form>`)
	})

	// 1. O comprador carrega em "Pagar": cria-se a sessão e manda-se para o checkout.
	http.HandleFunc("POST /comprar", func(w http.ResponseWriter, r *http.Request) {
		encomenda := r.FormValue("encomenda")
		sessao, err := cliente.CreateCheckoutSession(r.Context(), &spolly.CheckoutSessionParams{
			Amount:      1500000, // 15.000,00 Kz, em unidades menores
			Currency:    spolly.AOA,
			Description: "Encomenda " + encomenda,
			SuccessURL:  loja + "/obrigado", // volta com ?session_id=cs_...
			CancelURL:   loja + "/",
			Metadata:    map[string]string{"encomenda": encomenda},
		}) // o SDK põe a Idempotency-Key sozinho
		if err != nil {
			log.Print(err)
			http.Error(w, "não foi possível iniciar o pagamento", http.StatusBadGateway)
			return
		}
		http.Redirect(w, r, sessao.URL, http.StatusSeeOther)
	})

	// 2. O webhook: é aqui, e só aqui, que a encomenda passa a paga.
	http.HandleFunc("POST /webhooks/spolly", func(w http.ResponseWriter, r *http.Request) {
		evento, _, err := verificador.ParseRequest(r) // lê o corpo bruto e verifica a assinatura
		if err != nil {
			http.Error(w, "assinatura inválida", http.StatusBadRequest)
			return
		}
		mu.Lock()
		defer mu.Unlock()
		if tratados[evento.ID] {
			return // a mesma entrega outra vez: já está feito, responde 200
		}
		if evento.Type == webhook.EventPaymentSucceeded {
			var pagamento struct {
				ID       string            `json:"id"`
				Metadata map[string]string `json:"metadata"`
			}
			if err := json.Unmarshal(evento.Data.Object, &pagamento); err != nil {
				http.Error(w, "objeto ilegível", http.StatusBadRequest)
				return
			}
			encomenda := pagamento.Metadata["encomenda"]
			if encomenda == "" {
				// Um pagamento sem a encomenda (o evento de ensaio do painel, por
				// exemplo): não é desta loja marcar, e responde-se 200 na mesma.
				log.Printf("evento %s sem encomenda (%s): ignorado", evento.ID, pagamento.ID)
			} else {
				pagas[encomenda] = true
				log.Printf("encomenda %s paga (%s, evento %s)", encomenda, pagamento.ID, evento.ID)
			}
		}
		tratados[evento.ID] = true
	})

	// 3. O regresso: só mostra o estado, lido do lado do servidor. Não marca nada.
	http.HandleFunc("GET /obrigado", func(w http.ResponseWriter, r *http.Request) {
		sessao, err := cliente.GetCheckoutSession(r.Context(), r.URL.Query().Get("session_id"))
		if err != nil {
			log.Print(err)
			http.Error(w, "não foi possível ler o pagamento", http.StatusBadGateway)
			return
		}
		if sessao.Paid() {
			fmt.Fprintln(w, "Pagamento recebido. Obrigado!")
		} else {
			fmt.Fprintln(w, "A confirmar o pagamento. Avisamos quando entrar.")
		}
	})

	log.Print("a loja está em http://localhost:4242")
	log.Fatal(http.ListenAndServe(":4242", nil))
}

// loja.mjs: a loja mínima. Cria a sessão, recebe o webhook, mostra o regresso.
import { createServer } from "node:http";
import { SpollyPayments, constructEvent, isPaid } from "@spolly-ao/spolly-payments";

const spolly = new SpollyPayments(process.env.SPOLLY_SECRET_KEY, { baseURL: process.env.SPOLLY_API_URL });
const segredo = process.env.SPOLLY_WEBHOOK_SECRET;
const loja = process.env.LOJA_URL; // o endereço público desta loja, por exemplo o do túnel

const pagas = new Set(); // na tua loja, é a tabela das encomendas
const tratados = new Set(); // os eventos já tratados, pelo id

async function corpoBruto(req) {
  const partes = [];
  for await (const parte of req) partes.push(parte);
  return Buffer.concat(partes);
}

createServer(async (req, res) => {
  const url = new URL(req.url, "http://localhost");
  try {
    // A página da loja, com o botão de pagar.
    if (req.method === "GET" && url.pathname === "/") {
      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
      res.end('<form method="post" action="/comprar"><input name="encomenda" value="1042"> <button>Pagar 15.000,00 Kz</button></form>');
      return;
    }

    // 1. O comprador carrega em "Pagar": cria-se a sessão e manda-se para o checkout.
    if (req.method === "POST" && url.pathname === "/comprar") {
      const encomenda = new URLSearchParams((await corpoBruto(req)).toString()).get("encomenda");
      const sessao = await spolly.createCheckoutSession({
        amount: 1500000, // 15.000,00 Kz, em unidades menores
        currency: "AOA",
        description: `Encomenda ${encomenda}`,
        success_url: `${loja}/obrigado`, // volta com ?session_id=cs_...
        cancel_url: `${loja}/`,
        metadata: { encomenda },
      }); // o SDK põe a Idempotency-Key sozinho
      res.writeHead(303, { location: sessao.url }).end();
      return;
    }

    // 2. O webhook: é aqui, e só aqui, que a encomenda passa a paga.
    if (req.method === "POST" && url.pathname === "/webhooks/spolly") {
      let evento;
      try {
        // Com o corpo bruto, tal como chegou: um JSON relido já não bate.
        evento = constructEvent(await corpoBruto(req), req.headers["spolly-signature"], segredo);
      } catch {
        res.writeHead(400).end("assinatura inválida");
        return;
      }
      if (!tratados.has(evento.id)) {
        if (evento.type === "payment.succeeded") {
          const pagamento = evento.data.object;
          const encomenda = pagamento.metadata?.encomenda;
          if (!encomenda) {
            // Um pagamento sem a encomenda (o evento de ensaio do painel, por
            // exemplo): não é desta loja marcar, e responde-se 200 na mesma.
            console.log(`evento ${evento.id} sem encomenda (${pagamento.id}): ignorado`);
          } else {
            pagas.add(encomenda);
            console.log(`encomenda ${encomenda} paga (${pagamento.id}, evento ${evento.id})`);
          }
        }
        tratados.add(evento.id);
      }
      res.writeHead(200).end(); // a mesma entrega outra vez também leva 200
      return;
    }

    // 3. O regresso: só mostra o estado, lido do lado do servidor. Não marca nada.
    if (req.method === "GET" && url.pathname === "/obrigado") {
      const sessao = await spolly.getCheckoutSession(url.searchParams.get("session_id"));
      res.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
      res.end(isPaid(sessao) ? "Pagamento recebido. Obrigado!" : "A confirmar o pagamento. Avisamos quando entrar.");
      return;
    }

    res.writeHead(404).end();
  } catch (erro) {
    console.error(erro);
    res.writeHead(502).end("não foi possível falar com o Spolly Payments");
  }
}).listen(4242, () => console.log("a loja está em http://localhost:4242"));