Webhooks

import express from "express";
import { Qwicmail } from "@qwicmail/sdk";

const qm = new Qwicmail({ apiKey: process.env.QWICMAIL_API_KEY! });
const app = express();

// Important: receive the raw body, NOT the parsed JSON object.
app.post("/hooks/qwicmail",
  express.raw({ type: "application/json" }),
  (req, res) => {
    try {
      const evt = qm.webhooks.verify({
        body:      req.body,                                    // Buffer
        signature: req.header("X-Qwicmail-Signature")!,
        secret:    process.env.QWICMAIL_WEBHOOK_SECRET!,
        toleranceSeconds: 300,
      });
      // evt is the typed event payload
      console.log(evt.type, evt.message_id);
      res.sendStatus(200);
    } catch (e) {
      res.sendStatus(400);
    }
  });

from flask import Flask, request, abort
from qwicmail import Qwicmail, WebhookVerificationError

qm = Qwicmail(api_key=os.environ["QWICMAIL_API_KEY"])
app = Flask(__name__)

@app.post("/hooks/qwicmail")
def hook():
    try:
        evt = qm.webhooks.verify(
            body=request.get_data(),                          # raw bytes
            signature=request.headers["X-Qwicmail-Signature"],
            secret=os.environ["QWICMAIL_WEBHOOK_SECRET"],
            tolerance_seconds=300,
        )
    except WebhookVerificationError:
        abort(400)
    print(evt.type, evt.message_id)
    return "", 200

http.HandleFunc("/hooks/qwicmail", func(w http.ResponseWriter, r *http.Request) {
    raw, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "read", http.StatusBadRequest)
        return
    }
    evt, err := qm.Webhooks.Verify(qwicmail.VerifyParams{
        Body:             raw,
        Signature:        r.Header.Get("X-Qwicmail-Signature"),
        Secret:           os.Getenv("QWICMAIL_WEBHOOK_SECRET"),
        ToleranceSeconds: 300,
    })
    if err != nil {
        http.Error(w, "bad signature", http.StatusBadRequest)
        return
    }
    log.Println(evt.Type, evt.MessageID)
    w.WriteHeader(http.StatusOK)
})

require "sinatra"
require "qwicmail"

qm = Qwicmail::Client.new(api_key: ENV.fetch("QWICMAIL_API_KEY"))

post "/hooks/qwicmail" do
  raw = request.body.read
  begin
    evt = qm.webhooks.verify(
      body:              raw,
      signature:         request.env["HTTP_X_QWICMAIL_SIGNATURE"],
      secret:            ENV.fetch("QWICMAIL_WEBHOOK_SECRET"),
      tolerance_seconds: 300,
    )
  rescue Qwicmail::WebhookVerificationError
    halt 400
  end
  puts "#{evt.type} #{evt.message_id}"
  status 200
end

<?php
use Qwicmail\Client;
use Qwicmail\WebhookVerificationError;

$qm  = new Client(getenv("QWICMAIL_API_KEY"));
$raw = file_get_contents("php://input");

try {
    $evt = $qm->webhooks->verify([
        "body"              => $raw,
        "signature"         => $_SERVER["HTTP_X_QWICMAIL_SIGNATURE"] ?? "",
        "secret"            => getenv("QWICMAIL_WEBHOOK_SECRET"),
        "tolerance_seconds" => 300,
    ]);
} catch (WebhookVerificationError $e) {
    http_response_code(400);
    exit;
}
error_log("{$evt->type} {$evt->messageId}");
http_response_code(200);

@PostMapping(path = "/hooks/qwicmail",
             consumes = MediaType.ALL_VALUE)
public ResponseEntity<Void> hook(@RequestBody byte[] raw,
                                 @RequestHeader("X-Qwicmail-Signature") String sig) {
    try {
        Event evt = qm.webhooks().verify(VerifyParams.builder()
            .body(raw)
            .signature(sig)
            .secret(System.getenv("QWICMAIL_WEBHOOK_SECRET"))
            .toleranceSeconds(300)
            .build());
        log.info("{} {}", evt.type(), evt.messageId());
    } catch (WebhookVerificationException e) {
        return ResponseEntity.badRequest().build();
    }
    return ResponseEntity.ok().build();
}