SDKs

ns.judgments.create(
    name="needs_escalation",
    type="bool",
    question="Does this ticket need escalation?",
    context={"fields": ["state.subject", "state.body"]},
    engine={"name": "jev", "version": "current"},
    idempotency_key="create-needs-escalation-v1",
)

await ns.judgments.create(
  {
    name: "needs_escalation",
    type: "bool",
    question: "Does this ticket need escalation?",
    context: { fields: ["state.subject", "state.body"] },
    engine: { name: "jev", version: "current" },
  },
  { idempotencyKey: "create-needs-escalation-v1" },
);

from brussle import And

endpoint = db.webhook_endpoints.create(url="https://example.com/hooks/events", events=["job.*"])
secret = endpoint["secret"]  # keep it where your receiver can read it

ns = db.namespace("acme/prod/*")  # a template prefix covers every tenant under it
ns.subscriptions.create(
    name="urgent-enterprise",
    filters=And(("answers.urgency.p", "Gt", 0.8), ("attributes.plan", "Eq", "enterprise")),
    events=["entered", "exited"],
    endpoint=endpoint["id"],
)
db.webhook_endpoints.test(endpoint["id"])  # sends webhook.test, marked "test": true

const endpoint = await db.webhookEndpoints.create({ url: "https://example.com/hooks/events", events: ["job.*"] });
const secret = endpoint.secret; // keep it where your receiver can read it

const ns = db.namespace("acme/prod/*"); // a template prefix covers every tenant under it
await ns.subscriptions.create({
  name: "urgent-enterprise",
  filters: ["And", [["answers.urgency.p", "Gt", 0.8], ["attributes.plan", "Eq", "enterprise"]]],
  events: ["entered", "exited"],
  endpoint: endpoint.id,
});
await db.webhookEndpoints.test(endpoint.id); // sends webhook.test, marked "test": true

for event in db.events.iterate(cursor=last_seen, types=["subscription.*"], namespace_prefix="acme/prod/"):
    handle(event)
    last_seen = event["id"]

for await (const event of db.events.iterate({ cursor: lastSeen, types: ["subscription.*"], namespacePrefix: "acme/prod/" })) {
  await handle(event);
  lastSeen = event.id;
}

import os

from flask import Flask, request
from brussle import WebhookVerificationError, verify_webhook

WEBHOOK_SECRET = os.environ["WEBHOOK_SECRET"]  # fails at start-up when unset
app = Flask(__name__)

@app.post("/hooks/events")
def events():
    try:
        event = verify_webhook(request.get_data(), request.headers, WEBHOOK_SECRET)
    except WebhookVerificationError:
        return "", 400
    handle(event)
    return "", 204

import os

from fastapi import FastAPI, Request, Response
from brussle import WebhookVerificationError, verify_webhook

WEBHOOK_SECRET = os.environ["WEBHOOK_SECRET"]  # fails at start-up when unset
app = FastAPI()

@app.post("/hooks/events")
async def events(request: Request) -> Response:
    try:
        event = verify_webhook(await request.body(), request.headers, WEBHOOK_SECRET)
    except WebhookVerificationError:
        return Response(status_code=400)
    handle(event)
    return Response(status_code=204)

// app/hooks/events/route.ts
import { verifyWebhook, WebhookVerificationError } from "brussle";

const secret = process.env.WEBHOOK_SECRET;
if (!secret) throw new Error("WEBHOOK_SECRET is not set");

// An arrow function, so TypeScript keeps `secret` narrowed to a string inside it.
export const POST = async (request: Request) => {
  const body = new Uint8Array(await request.arrayBuffer());
  try {
    const event = await verifyWebhook(body, request.headers, secret);
    await handle(event);
  } catch (error) {
    if (error instanceof WebhookVerificationError) return new Response(null, { status: 400 });
    throw error;
  }
  return new Response(null, { status: 204 });
};

import express from "express";
import { verifyWebhook, WebhookVerificationError } from "brussle";

const app = express();
const secret = process.env.WEBHOOK_SECRET;
if (!secret) throw new Error("WEBHOOK_SECRET is not set");

// express.raw keeps the body as the bytes received.
app.post("/hooks/events", express.raw({ type: "application/json" }), async (req, res) => {
  try {
    const event = await verifyWebhook(req.body, req.headers, secret);
    await handle(event);
    res.sendStatus(204);
  } catch (error) {
    if (error instanceof WebhookVerificationError) res.sendStatus(400);
    else throw error;
  }
});

from brussle.types import WebhookEvent

def handle(event: WebhookEvent) -> None:
    if event.get("test"):
        return
    if event["type"] == "subscription.entered":
        escalate(event["data"]["namespace"], event["data"]["document"]["id"])
    elif event["type"] == "job.completed":
        print("job done:", event["data"]["job"]["id"])

import type { WebhookEvent } from "brussle";

async function handle(event: WebhookEvent) {
  if (event.test) return;
  switch (event.type) {
    case "subscription.entered":
      await escalate(event.data.namespace, event.data.document.id);
      break;
    case "job.completed":
      console.log("job done:", event.data.job.id);
      break;
  }
}